Fix C# warnings.

csharp/src/Microsoft.ML.OnnxRuntime/DisposableNamedOnnxValue.shared.cs

@@ -83,7 +83,7 @@ public class DisposableNamedOnnxValue : NamedOnnxValue, IDisposable
         /// Ctor
         /// </summary>
         /// <param name="name">Name of the output value</param>
-        /// <param name="value">Managed object created to represent output value, such as DenseTensor<T>
+        /// <param name="value">Managed object created to represent output value, such as DenseTensor{T};
         /// List or Dictionary
         /// </param>
         /// <param name="elementType">Tensor element type if value type is a Tensor</param>
@@ -133,7 +133,7 @@ private DisposableNamedOnnxValue(string name, Object value, MapHelper mapHelper,
         public TensorElementType ElementType { get; }
 
         /// <summary>
-        /// Overrides the base class method. With respect to pinnedMemoryHandle, it has no operation
+        /// Overrides the base class method. With respect to memoryHolder, it has no operation
         /// to do, as this class maintains a native buffer via _ortValueHolder and the memory will be
         /// disposed by it. This is the case when we are dealing with an OrtValue that is backed by native memory
         /// and not by pinned managed memory.
@@ -142,15 +142,15 @@ private DisposableNamedOnnxValue(string name, Object value, MapHelper mapHelper,
         /// but the interface (derived from NamedOnnxValue) allows it to be passed as output and one of the test
         /// cases does it. Unless we deprecate and re-do the interface, we must support it.
         /// </summary>
-        /// <param name="pinnedMemoryHandle">always set to null</param>
+        /// <param name="memoryHolder">always set to null</param>
         /// <returns>Native OrtValue handle</returns>
         internal override IntPtr InputToOrtValueHandle(NodeMetadata metadata, out IDisposable memoryHolder)
         {
             if (_ortValueHolder == null)
             {
                 throw new InvalidOperationException("The instance of this class does not own an OrtValue");
             }
-            // PinnedMemoryHandle holds the default value as DisposableNamedOnnxValue
+            // memoryHolder holds the default value as DisposableNamedOnnxValue
             // doesn't hold any managed buffer (that needs to be pinned)
             memoryHolder = null;
             // Return non-owning instance of OrtValue

csharp/src/Microsoft.ML.OnnxRuntime/InferenceSession.shared.cs

@@ -908,7 +908,7 @@ private static IntPtr ExtractOrtValueHandleForOutput(NamedOnnxValue output, Node
         /// </summary>
         /// <param name="values">names to convert to zero terminated utf8 and pin</param>
         /// <param name="nameExtractor">extractor functor that helps extracting names from inputs</param>
-        /// <param name="metaDict">inputs/outputs metadata</param>
+        /// <param name="metaLookup">inputs/outputs metadata</param>
         /// <returns></returns>
         private static IntPtr[] LookupUtf8Names<T>(IReadOnlyCollection<T> values, NameExtractor<T> nameExtractor,
             MetadataLookup metaLookup)
@@ -1222,7 +1222,6 @@ private void Init(byte[] modelData, SessionOptions options,
         /// Initializes the session object with a native session handle
         /// </summary>
         /// <param name="session">Value of a native session object</param>
-        /// <param name="options">Session options</param>
         private void InitWithSessionHandle(IntPtr session)
         {
             _nativeHandle = session;
@@ -2075,7 +2074,7 @@ public long Version
         /// <summary>
         /// Custom metadata key/value pairs
         /// </summary>
-        /// <value>An instance of a Dictionary<string,string></value>
+        /// <value>An instance of a Dictionary{string,string}</value>
         public Dictionary<string, string> CustomMetadataMap
         {
             get

csharp/src/Microsoft.ML.OnnxRuntime/ManagedProjections.shared.cs

@@ -65,7 +65,7 @@ internal static OrtValue CreateProjection(NamedOnnxValue namedOnnxValue, NodeMet
         /// The function creates OrtValue objects for each element of the sequence
         /// and then creates an OrtValue for the whole sequence.
         /// </summary>
-        /// <param name="namedOnnxValue">NamedOnnxValue containing a IEnumerable<NameOnnValue></param>
+        /// <param name="namedOnnxValue">NamedOnnxValue containing a IEnumerable{NamedOnnxValue}</param>
         /// <param name="metadata">sequence metadata</param>
         /// <returns>OrtValue that represents a sequence</returns>
         /// <exception cref="OnnxRuntimeException"></exception>

csharp/src/Microsoft.ML.OnnxRuntime/NamedOnnxValue.shared.cs

@@ -53,13 +53,13 @@ internal MapHelper(TensorBase keys, TensorBase values)
     /// Other sequences and maps. Although the OnnxValueType is exposed,
     /// the caller is supposed to know the actual data type contained.
     /// 
-    /// The convention is that for tensors, it would contain a DenseTensor<T> instance or
-    /// anything derived from Tensor<T>.
+    /// The convention is that for tensors, it would contain a DenseTensor{T} instance or
+    /// anything derived from Tensor{T}.
     /// 
-    /// For sequences, it would contain a IList<T> where T is an instance of NamedOnnxValue that
+    /// For sequences, it would contain a IList{T} where T is an instance of NamedOnnxValue that
     /// would contain a tensor or another type.
     /// 
-    /// For Maps, it would contain a IDictionary<K, V> where K,V are primitive types or strings.
+    /// For Maps, it would contain a IDictionary{K, V} where K,V are primitive types or strings.
     /// 
     /// </summary>
     public class NamedOnnxValue
@@ -153,7 +153,7 @@ public static NamedOnnxValue CreateFromSequence<T>(string name, IEnumerable<T> v
         }
 
         /// <summary>
-        /// Instantiates NamedOnnxValue that contains IDictionary<K, V>
+        /// Instantiates NamedOnnxValue that contains IDictionary{K, V}
         /// </summary>
         /// <typeparam name="K">Keys type</typeparam>
         /// <typeparam name="V">Values type</typeparam>
@@ -225,7 +225,7 @@ public IDictionary<K, V> AsDictionary<K, V>()
         /// based on the pinned managed memory. The caller is responsible for Disposing
         /// both OrtValue and pinnedMemoryHandle
         /// </summary>
-        /// <param name="pinnedMemoryHandle">dispose after returned OrtValus is disposed</param>
+        /// <param name="memoryOwner">dispose after returned OrtValue is disposed</param>
         /// <returns>The native OrtValue handle</returns>
         internal virtual IntPtr InputToOrtValueHandle(NodeMetadata metadata, out IDisposable memoryOwner)
         {
@@ -272,12 +272,6 @@ internal virtual IntPtr OutputToOrtValueHandle(NodeMetadata metadata, out IDispo
                 $" Use Run() overloads that return DisposableNamedOnnxValue to get access to all Onnx value types that may be returned as output.");
         }
 
-        /// <summary>
-        /// This method is used internally to feed dictionary keys
-        /// to create an OrtValue for map keys
-        /// </summary>
-        /// <typeparam name="K"></typeparam>
-        /// <returns>DenseTensor<K>"</returns>
         internal TensorBase GetDictionaryKeys()
         {
             if (ValueType != OnnxValueType.ONNX_TYPE_MAP)
@@ -289,11 +283,6 @@ internal TensorBase GetDictionaryKeys()
             return _mapHelper.Keys;
         }
 
-        /// <summary>
-        /// 
-        /// </summary>
-        /// <typeparam name="V"></typeparam>
-        /// <returns>DenseTensor<V>"</returns>
         internal TensorBase GetDictionaryValues()
         {
             if (ValueType != OnnxValueType.ONNX_TYPE_MAP)

csharp/src/Microsoft.ML.OnnxRuntime/NativeMethods.shared.cs

@@ -1506,7 +1506,7 @@ IntPtr[] outputValues /* An array of output value pointers. Array must be alloca
         /// <summary>
         /// Destroy OrtIoBinding instance created by OrtCreateIoBinding
         /// </summary>
-        /// <param name="io_bidning">instance of OrtIoBinding</param>
+        /// <param name="io_binding">instance of OrtIoBinding</param>
         [UnmanagedFunctionPointer(CallingConvention.Winapi)]
         public delegate void DOrtReleaseIoBinding(IntPtr /*(OrtIoBinding)*/ io_binding);
 
@@ -1516,7 +1516,7 @@ IntPtr[] outputValues /* An array of output value pointers. Array must be alloca
         /// Bind OrtValue to the model input with the specified name
         /// If binding with the specified name already exists, it will be replaced
         /// </summary>
-        /// <param name="io_bidning">instance of OrtIoBinding</param>
+        /// <param name="io_binding">instance of OrtIoBinding</param>
         /// <param name="name">model input name (utf-8)</param>
         /// <param name="ort_value">OrtValue that is used for input (may wrap arbitrary memory).
         ///      The param instance is copied internally so this argument may be released.
@@ -1544,7 +1544,7 @@ IntPtr[] outputValues /* An array of output value pointers. Array must be alloca
         /// Bind OrtValue to the model output with the specified name
         /// If binding with the specified name already exists, it will be replaced
         /// </summary>
-        /// <param name="io_bidning">instance of OrtIoBinding</param>
+        /// <param name="io_binding">instance of OrtIoBinding</param>
         /// <param name="name">model output name (utf-8)</param>
         /// <param name="ort_value">OrtValue that is used for output (may wrap arbitrary memory).
         ///      The param instance is copied internally so this argument may be released.
@@ -1605,7 +1605,7 @@ IntPtr[] outputValues /* An array of output value pointers. Array must be alloca
         /// The function returns output values after the model has been run with RunWithBinding()
         /// It returns a natively allocated buffer of OrtValue pointers. All of the OrtValues must be individually
         /// released after no longer needed. You may use OrtValue disposable class to wrap the native handle and properly dispose it
-        /// in connection with DisposableList<T>. All values are returned in the same order as they were bound.
+        /// in connection with DisposableList{T}. All values are returned in the same order as they were bound.
         /// The buffer that contains OrtValues must deallocated using the same allocator that was specified as an argument.
         /// You may use an instance OrtMemoryAllocation to properly dispose of the native memory.
         /// </summary>
@@ -1643,9 +1643,7 @@ IntPtr[] outputValues /* An array of output value pointers. Array must be alloca
         /// <summary>
         /// Provides element-level access into a tensor.
         /// </summary>
-        /// <param name="location_values">a pointer to an array of index values that specify an element's location in the tensor data blob</param>
-        /// <param name="location_values_count">length of location_values</param>
-        /// <param name="out">a pointer to the element specified by location_values</param>
+        /// <param name="io_binding">instance of OrtIoBinding</param>
         [UnmanagedFunctionPointer(CallingConvention.Winapi)]
         public delegate void DOrtTensorAt(IntPtr /*(OrtIoBinding)*/ io_binding);
 
@@ -1656,10 +1654,11 @@ IntPtr[] outputValues /* An array of output value pointers. Array must be alloca
         /// sharing between multiple sessions that use the same env instance.
         /// Lifetime of the created allocator will be valid for the duration of the environment.
         /// Returns an error if an allocator with the same OrtMemoryInfo is already registered.
+        /// </summary>
         /// <param name="env">Native OrtEnv instance</param>
         /// <param name="memInfo">Native OrtMemoryInfo instance</param>
         /// <param name="arenaCfg">Native OrtArenaCfg instance</param>
-        /// <retruns>A pointer to native ortStatus indicating success/failure</retruns>
+        /// <returns>A pointer to native ortStatus indicating success/failure</returns>
         [UnmanagedFunctionPointer(CallingConvention.Winapi)]
         public delegate IntPtr /*(OrtStatus*)*/ DOrtCreateAndRegisterAllocator(IntPtr /*(OrtEnv*)*/ env,
                                                                                IntPtr /*(const OrtMemoryInfo*)*/ memInfo,
@@ -1890,7 +1889,7 @@ IntPtr[] outputValues /* An array of output value pointers. Array must be alloca
         public static DOrtFillStringTensor OrtFillStringTensor;
 
         /// \param value A tensor created from OrtCreateTensor... function.
-        /// \param index The index of the entry in the tensor to resize. <summary>
+        /// \param index The index of the entry in the tensor to resize.
         /// \param length_in_bytes Length to resize the string to.
         /// \param buffer The resized buffer.
         [UnmanagedFunctionPointer(CallingConvention.Winapi)]

csharp/src/Microsoft.ML.OnnxRuntime/NativeOnnxValueHelper.shared.cs

@@ -226,7 +226,7 @@ internal MarshaledString(string input)
         }
 
         /// <summary>
-        // Native allocation (UTF8-8 string length with terminating zero)
+        /// Native allocation (UTF8-8 string length with terminating zero)
         /// </summary>
         internal int Length { get; private set; }
 

csharp/src/Microsoft.ML.OnnxRuntime/OrtEnv.shared.cs

@@ -126,7 +126,7 @@ private OrtEnv(IntPtr handle, OrtLoggingLevel logLevel)
         /// <param name="severity"></param>
         /// <param name="category"></param>
         /// <param name="logid"></param>
-        /// <param name="code_location"></param>
+        /// <param name="codeLocation"></param>
         /// <param name="message"></param>
         private static void LoggingFunctionThunk(IntPtr param,
                 IntPtr severity,

csharp/src/Microsoft.ML.OnnxRuntime/OrtFloat16.shared.cs

@@ -134,11 +134,11 @@ internal static uint BFloat16BitsToSingleBits(ushort bfloatBits)
         }
 
         /// <summary>
-        /// Creates float NaN with the given sign and fp16 significand shifted << 54
+        /// Creates float NaN with the given sign and fp16 significand shifted &lt;&lt; 54
         /// </summary>
         /// <param name="sign">true for negative</param>
         /// <param name="significand">should be shifted 54 bits left before calling the function
-        /// so only 8 bits of signidicand remains</param>
+        /// so only 8 bits of significand remains</param>
         /// <returns></returns>
         internal static float CreateSingleNaN(bool sign, ulong significand)
         {
@@ -416,12 +416,11 @@ internal static ushort ExtractTrailingSignificandFromBits(ushort bits)
 
         /// <summary>
         /// Compares values of two Float16
-        /// 
         /// </summary>
         /// <param name="left">left hand side</param>
         /// <param name="right">right hand side</param>
         /// <returns>returns true if left is greater or equal than right according to IEEE</returns>
-        /// <inheritdoc cref="IComparisonOperators{TSelf, TOther, TResult}.op_GreaterThanOrEqual(TSelf, TOther)" />
+        /// <inheritdoc />
         public static bool operator >=(Float16 left, Float16 right)
         {
             return right <= left;
@@ -492,7 +491,7 @@ public static bool IsNaN(Float16 value)
         /// Determines whether the specified value is negative.
         /// </summary>
         /// <param name="value">Float16 instance</param>
-        /// <returns>true if the value is negative</returns></returns>
+        /// <returns>true if the value is negative</returns>
         public static bool IsNegative(Float16 value)
         {
             return (short)(value.value) < 0;
@@ -1115,7 +1114,7 @@ public static bool IsNaN(BFloat16 value)
         /// Determines whether the specified value is negative.
         /// </summary>
         /// <param name="value">BFloat16 instance</param>
-        /// <returns>true if the value is negative</returns></returns>
+        /// <returns>true if the value is negative</returns>
         public static bool IsNegative(BFloat16 value)
         {
             return (short)(value.value) < 0;

csharp/src/Microsoft.ML.OnnxRuntime/ProviderOptions.shared.cs

@@ -318,9 +318,9 @@ public static void StringToDict(string s, Dictionary<string, string> dict)
     }
 
     /// <summary>
-    /// CoreML flags for use with SessionOptions
+    /// CoreML flags for use with SessionOptions.
+    /// See https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/providers/coreml/coreml_provider_factory.h
     /// </summary>
-    /// <see cref="https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/providers/coreml/coreml_provider_factory.h"/>
     [Flags]
     public enum CoreMLFlags : uint
     {
@@ -332,9 +332,9 @@ public enum CoreMLFlags : uint
     }
 
     /// <summary>
-    /// NNAPI flags for use with SessionOptions
+    /// NNAPI flags for use with SessionOptions.
+    /// See https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/providers/nnapi/nnapi_provider_factory.h
     /// </summary>
-    /// <see cref="https://github.com/microsoft/onnxruntime/blob/main/include/onnxruntime/core/providers/nnapi/nnapi_provider_factory.h"/>
     [Flags]
     public enum NnapiFlags
     {

csharp/src/Microsoft.ML.OnnxRuntime/SessionOptions.shared.cs

@@ -768,8 +768,8 @@ public int LogVerbosityLevel
         private int _logVerbosityLevel = 0;
 
         /// <summary>
-        // Sets the number of threads used to parallelize the execution within nodes
-        // A value of 0 means ORT will pick a default
+        /// Sets the number of threads used to parallelize the execution within nodes
+        /// A value of 0 means ORT will pick a default
         /// </summary>
         /// <value>returns _intraOpNumThreads value</value>
         public int IntraOpNumThreads
@@ -787,9 +787,9 @@ public int IntraOpNumThreads
         private int _intraOpNumThreads = 0; // set to what is set in C++ SessionOptions by default;
 
         /// <summary>
-        // Sets the number of threads used to parallelize the execution of the graph (across nodes)
-        // If sequential execution is enabled this value is ignored
-        // A value of 0 means ORT will pick a default
+        /// Sets the number of threads used to parallelize the execution of the graph (across nodes)
+        /// If sequential execution is enabled this value is ignored
+        /// A value of 0 means ORT will pick a default
         /// </summary>
         /// <value>returns _interOpNumThreads value</value>
         public int InterOpNumThreads