Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System/sys/system/runtime/interopservices/DefaultParameterValueAttribute.cs

@@ -0,0 +1,29 @@
+// ==++==
+//
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+//
+// ==--==
+
+namespace System.Runtime.InteropServices {
+
+    using System;
+
+    //
+    // The DefaultParameterValueAttribute is used in C# to set 
+    // the default value for parameters when calling methods
+    // from other languages. This is particularly useful for 
+    // methods defined in COM interop interfaces.
+    //
+    [AttributeUsageAttribute(AttributeTargets.Parameter)]
+    public sealed class DefaultParameterValueAttribute : System.Attribute
+    {
+         public DefaultParameterValueAttribute(object value)
+         {
+             this.value = value;
+         }
+
+         public object Value { get { return this.value; } }
+
+         private object value;
+    }
+}

mcs/class/referencesource/System/sys/system/runtime/interopservices/handlecollector.cs

@@ -0,0 +1,121 @@
+// ==++==
+// 
+//   Copyright (c) Microsoft Corporation.  All rights reserved.
+// 
+// ==--==
+
+namespace System.Runtime.InteropServices 
+{
+    using System;
+    using System.Threading;
+
+    public sealed class HandleCollector {
+        private const int deltaPercent = 10; // this is used for increasing the threshold.        
+        private string name;
+        private int initialThreshold;
+        private int maximumThreshold;
+        private int threshold;
+        private int handleCount;
+        
+        private int[] gc_counts = new int [3];
+        private int    gc_gen = 0;
+            
+        public HandleCollector( string name, int initialThreshold ) : 
+            this( name, initialThreshold,  int.MaxValue) {
+        }
+
+        public HandleCollector( string name, int initialThreshold, int maximumThreshold ) {
+            if( initialThreshold < 0) {
+                throw new ArgumentOutOfRangeException("initialThreshold", 
+                    SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
+            }                                                                         
+
+            if( maximumThreshold < 0) {
+                throw new ArgumentOutOfRangeException("maximumThreshold", 
+                    SR.GetString(SR.ArgumentOutOfRange_NeedNonNegNumRequired));
+            }                                                                         
+
+            if( initialThreshold > maximumThreshold) {
+                throw new ArgumentException(SR.GetString(SR.Argument_InvalidThreshold));
+            }
+
+            if ( name != null) {
+                this.name = name;
+            }
+            else {
+                this.name = String.Empty;
+            }
+
+            this.initialThreshold = initialThreshold;
+            this.maximumThreshold = maximumThreshold ;
+            this.threshold = initialThreshold;
+            this.handleCount = 0;
+        }
+
+        public int Count { get {return handleCount;} }
+
+        public int InitialThreshold { get  { return initialThreshold;} }
+
+        public int MaximumThreshold { get { return  maximumThreshold;} }
+
+        public string Name { get {return name;} }
+
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2001:AvoidCallingProblematicMethods")]  // Keep call to GC.Collect()
+#if FEATURE_LEGACYNETCF
+        [System.Security.SecuritySafeCritical] 
+#endif// FEATURE_LEGACYNETCF
+        public void Add () {
+            int gen_collect = -1;
+            Interlocked.Increment( ref handleCount);
+            if( handleCount < 0) {
+                throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_HCCountOverflow));                 
+            }
+
+            if (handleCount > threshold) {
+                lock (this) {
+                    threshold = handleCount + (handleCount/deltaPercent);
+                    gen_collect = gc_gen;
+                    if (gc_gen < 2) {
+                        gc_gen++;
+                    }
+                }                
+            }
+
+            if ((gen_collect >= 0) && 
+                    ((gen_collect == 0) || 
+                    (gc_counts[gen_collect] == GC.CollectionCount (gen_collect)))) {
+                    GC.Collect (gen_collect);
+                    Thread.Sleep (10*gen_collect);
+            }
+
+            //don't bother with gen0. 
+            for (int i = 1; i < 3; i++) {
+                gc_counts [i] = GC.CollectionCount (i);
+            }
+        }
+
+        public void Remove () {
+            Interlocked.Decrement( ref handleCount);
+            if (handleCount < 0) {
+                throw new InvalidOperationException(SR.GetString(SR.InvalidOperation_HCCountOverflow)); 
+            }
+
+            int newThreshold =  handleCount + handleCount/deltaPercent;
+            if (newThreshold < (threshold - threshold/deltaPercent)) {
+                lock( this) {
+                   if (newThreshold > initialThreshold) {
+                        threshold = newThreshold;
+                    }
+                    else {
+                        threshold = initialThreshold;
+                    }
+                    gc_gen = 0;
+                }
+            }
+            
+            for (int i = 1; i < 3; i++) {
+                gc_counts [i] = GC.CollectionCount (i);
+            }            
+        }
+    }
+}