Debug.Assert(ProcessorIdRefreshRate <= ProcessorIdCacheCountDownMask);
- // Mask with Int32.MaxValue to ensure the execution Id is not negative
- t_currentProcessorIdCache = ((currentProcessorId << ProcessorIdCacheShift) & Int32.MaxValue) | ProcessorIdRefreshRate;
+ // Mask with int.MaxValue to ensure the execution Id is not negative
+ t_currentProcessorIdCache = ((currentProcessorId << ProcessorIdCacheShift) & int.MaxValue) | ProcessorIdRefreshRate;
return currentProcessorId;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining)]
- public static void TraceOperationCreation(Task task, String operationName)
+ public static void TraceOperationCreation(Task task, string operationName)
{
AsyncCausalityTracer.TraceOperationCreation(CausalityTraceLevel.Required, task.Id, operationName, 0);
}
internal static readonly Type[] ClassTypes = {
typeof(Empty),
typeof(void),
- typeof(Boolean),
- typeof(Char),
- typeof(SByte),
- typeof(Byte),
- typeof(Int16),
- typeof(UInt16),
- typeof(Int32),
- typeof(UInt32),
- typeof(Int64),
- typeof(UInt64),
- typeof(Single),
- typeof(Double),
- typeof(String),
+ typeof(bool),
+ typeof(char),
+ typeof(sbyte),
+ typeof(byte),
+ typeof(short),
+ typeof(ushort),
+ typeof(int),
+ typeof(uint),
+ typeof(long),
+ typeof(ulong),
+ typeof(float),
+ typeof(double),
+ typeof(string),
typeof(void),
typeof(DateTime),
typeof(TimeSpan),
- typeof(Object),
- typeof(Decimal),
+ typeof(object),
+ typeof(decimal),
null, // Enums - what do we do here?
typeof(Missing),
typeof(DBNull),
private static int GetCVTypeFromClass(Type ctype)
{
Debug.Assert(ctype != null);
- Debug.Assert(ClassTypes[CV_OBJECT] == typeof(Object), "OAVariantLib::ClassTypes[CV_OBJECT] == Object.class");
+ Debug.Assert(ClassTypes[CV_OBJECT] == typeof(object), "OAVariantLib::ClassTypes[CV_OBJECT] == Object.class");
int cvtype = -1;
for (int i = 0; i < ClassTypes.Length; i++)
*
* @return the data associated with the value.
*/
- public Object GetValue(string name, Object defaultValue)
+ public object GetValue(string name, object defaultValue)
{
return InternalGetValue(name, defaultValue, false, true);
}
- public Object GetValue(string name, Object defaultValue, RegistryValueOptions options)
+ public object GetValue(string name, object defaultValue, RegistryValueOptions options)
{
if (options < RegistryValueOptions.None || options > RegistryValueOptions.DoNotExpandEnvironmentNames)
{
return InternalGetValue(name, defaultValue, doNotExpand, true);
}
- internal Object InternalGetValue(string name, Object defaultValue, bool doNotExpand, bool checkSecurity)
+ internal object InternalGetValue(string name, object defaultValue, bool doNotExpand, bool checkSecurity)
{
if (checkSecurity)
{
EnsureNotDisposed();
}
- Object data = defaultValue;
+ object data = defaultValue;
int type = 0;
int datasize = 0;
byte[] blob = new byte[size];
while (Interop.Errors.ERROR_MORE_DATA == (r = Win32Native.RegQueryValueEx(_hkey, name, null, ref type, blob, ref sizeInput)))
{
- if (size == Int32.MaxValue)
+ if (size == int.MaxValue)
{
- // ERROR_MORE_DATA was returned however we cannot increase the buffer size beyond Int32.MaxValue
+ // ERROR_MORE_DATA was returned however we cannot increase the buffer size beyond int.MaxValue
Win32Error(r, name);
}
- else if (size > (Int32.MaxValue / 2))
+ else if (size > (int.MaxValue / 2))
{
// at this point in the loop "size * 2" would cause an overflow
- size = Int32.MaxValue;
+ size = int.MaxValue;
}
else
{
* @param name Name of value to store data in.
* @param value Data to store.
*/
- public void SetValue(string name, Object value)
+ public void SetValue(string name, object value)
{
SetValue(name, value, RegistryValueKind.Unknown);
}
- public unsafe void SetValue(string name, Object value, RegistryValueKind valueKind)
+ public unsafe void SetValue(string name, object value, RegistryValueKind valueKind)
{
if (value == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.value);
Win32Error(ret, null);
}
- private RegistryValueKind CalculateValueKind(Object value)
+ private RegistryValueKind CalculateValueKind(object value)
{
// This logic matches what used to be in SetValue(string name, object value) in the v1.0 and v1.1 days.
// Even though we could add detection for an int64 in here, we want to maintain compatibility with the
// old behavior.
- if (value is Int32)
+ if (value is int)
return RegistryValueKind.DWord;
else if (value is Array)
{
internal static extern int RoGetActivationFactory(
[MarshalAs(UnmanagedType.HString)] string activatableClassId,
[In] ref Guid iid,
- [Out, MarshalAs(UnmanagedType.IInspectable)] out Object factory);
+ [Out, MarshalAs(UnmanagedType.IInspectable)] out object factory);
#endif
}
}
internal uint Type;
}
- internal const String ADVAPI32 = "advapi32.dll";
- internal const String SHELL32 = "shell32.dll";
- internal const String SHIM = "mscoree.dll";
- internal const String CRYPT32 = "crypt32.dll";
- internal const String SECUR32 = "secur32.dll";
- internal const String MSCORWKS = "coreclr.dll";
+ internal const string ADVAPI32 = "advapi32.dll";
+ internal const string SHELL32 = "shell32.dll";
+ internal const string SHIM = "mscoree.dll";
+ internal const string CRYPT32 = "crypt32.dll";
+ internal const string SECUR32 = "secur32.dll";
+ internal const string MSCORWKS = "coreclr.dll";
[DllImport(Interop.Libraries.Kernel32, EntryPoint = "LocalAlloc")]
internal static extern IntPtr LocalAlloc_NoSafeHandle(int uFlags, UIntPtr sizetdwBytes);
internal static extern int lstrlenW(IntPtr ptr);
[DllImport(Interop.Libraries.OleAut32, CharSet = CharSet.Unicode)]
- internal static extern IntPtr SysAllocStringLen(String src, int len); // BSTR
+ internal static extern IntPtr SysAllocStringLen(string src, int len); // BSTR
[DllImport(Interop.Libraries.OleAut32)]
internal static extern uint SysStringLen(IntPtr bstr);
#if FEATURE_WIN32_REGISTRY
[DllImport(ADVAPI32, CharSet = CharSet.Auto, BestFitMapping = false)]
- internal static extern int RegDeleteValue(SafeRegistryHandle hKey, String lpValueName);
+ internal static extern int RegDeleteValue(SafeRegistryHandle hKey, string lpValueName);
[DllImport(ADVAPI32, CharSet = CharSet.Auto, BestFitMapping = false)]
internal static extern unsafe int RegEnumKeyEx(SafeRegistryHandle hKey, int dwIndex,
int[] lpcbData);
[DllImport(ADVAPI32, CharSet = CharSet.Auto, BestFitMapping = false)]
- internal static extern int RegOpenKeyEx(SafeRegistryHandle hKey, String lpSubKey,
+ internal static extern int RegOpenKeyEx(SafeRegistryHandle hKey, string lpSubKey,
int ulOptions, int samDesired, out SafeRegistryHandle hkResult);
[DllImport(ADVAPI32, CharSet = CharSet.Auto, BestFitMapping = false)]
- internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, String lpValueName,
+ internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, string lpValueName,
int[] lpReserved, ref int lpType, [Out] byte[] lpData,
ref int lpcbData);
[DllImport(ADVAPI32, CharSet = CharSet.Auto, BestFitMapping = false)]
- internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, String lpValueName,
+ internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, string lpValueName,
int[] lpReserved, ref int lpType, ref int lpData,
ref int lpcbData);
[DllImport(ADVAPI32, CharSet = CharSet.Auto, BestFitMapping = false)]
- internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, String lpValueName,
+ internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, string lpValueName,
int[] lpReserved, ref int lpType, ref long lpData,
ref int lpcbData);
[DllImport(ADVAPI32, CharSet = CharSet.Auto, BestFitMapping = false)]
- internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, String lpValueName,
+ internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, string lpValueName,
int[] lpReserved, ref int lpType, [Out] char[] lpData,
ref int lpcbData);
[DllImport(ADVAPI32, CharSet = CharSet.Auto, BestFitMapping = false)]
- internal static extern int RegSetValueEx(SafeRegistryHandle hKey, String lpValueName,
+ internal static extern int RegSetValueEx(SafeRegistryHandle hKey, string lpValueName,
int Reserved, RegistryValueKind dwType, byte[] lpData, int cbData);
[DllImport(ADVAPI32, CharSet = CharSet.Auto, BestFitMapping = false)]
- internal static extern int RegSetValueEx(SafeRegistryHandle hKey, String lpValueName,
+ internal static extern int RegSetValueEx(SafeRegistryHandle hKey, string lpValueName,
int Reserved, RegistryValueKind dwType, ref int lpData, int cbData);
[DllImport(ADVAPI32, CharSet = CharSet.Auto, BestFitMapping = false)]
- internal static extern int RegSetValueEx(SafeRegistryHandle hKey, String lpValueName,
+ internal static extern int RegSetValueEx(SafeRegistryHandle hKey, string lpValueName,
int Reserved, RegistryValueKind dwType, ref long lpData, int cbData);
[DllImport(ADVAPI32, CharSet = CharSet.Auto, BestFitMapping = false)]
- internal static extern int RegSetValueEx(SafeRegistryHandle hKey, String lpValueName,
- int Reserved, RegistryValueKind dwType, String lpData, int cbData);
+ internal static extern int RegSetValueEx(SafeRegistryHandle hKey, string lpValueName,
+ int Reserved, RegistryValueKind dwType, string lpData, int cbData);
#endif // FEATURE_WIN32_REGISTRY
[DllImport(Interop.Libraries.Kernel32, CharSet = CharSet.Auto, SetLastError = true, BestFitMapping = false)]
- internal static extern int ExpandEnvironmentStrings(String lpSrc, [Out]StringBuilder lpDst, int nSize);
+ internal static extern int ExpandEnvironmentStrings(string lpSrc, [Out]StringBuilder lpDst, int nSize);
[DllImport(Interop.Libraries.Kernel32)]
internal static extern IntPtr LocalReAlloc(IntPtr handle, IntPtr sizetcbBytes, int uFlags);
private string[] _Entries;
#pragma warning disable 169
- private String _AppBase; // for compat with v1.1
+ private string _AppBase; // for compat with v1.1
#pragma warning restore 169
// A collection of strings used to indicate which breaking changes shouldn't be applied
get
{
if (_Entries == null)
- _Entries = new String[(int)LoaderInformation.LoaderMaximum];
+ _Entries = new string[(int)LoaderInformation.LoaderMaximum];
return _Entries;
}
}
- public String ApplicationBase
+ public string ApplicationBase
{
get
{
return _CompatFlags;
}
- public void SetCompatibilitySwitches(IEnumerable<String> switches)
+ public void SetCompatibilitySwitches(IEnumerable<string> switches)
{
if (switches != null)
{
_CompatFlags = new Dictionary<string, object>();
- foreach (String str in switches)
+ foreach (string str in switches)
{
_CompatFlags.Add(str, null);
}
}
// A target Framework moniker, in a format parsible by the FrameworkName class.
- public String TargetFrameworkName
+ public string TargetFrameworkName
{
get
{
}
}
- public String ApplicationName
+ public string ApplicationName
{
get
{
}
// Inherited from object
- public override bool Equals(Object o)
+ public override bool Equals(object o)
{
throw new NotSupportedException(SR.NotSupported_NYI);
}
for (int i = 0; i < lengths.Length; ++i)
{
long len = lengths[i];
- if (len > Int32.MaxValue || len < Int32.MinValue)
+ if (len > int.MaxValue || len < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.len, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
intLengths[i] = (int)len;
}
public static void Copy(Array sourceArray, Array destinationArray, long length)
{
- if (length > Int32.MaxValue || length < Int32.MinValue)
+ if (length > int.MaxValue || length < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
Array.Copy(sourceArray, destinationArray, (int)length);
public static void Copy(Array sourceArray, long sourceIndex, Array destinationArray, long destinationIndex, long length)
{
- if (sourceIndex > Int32.MaxValue || sourceIndex < Int32.MinValue)
+ if (sourceIndex > int.MaxValue || sourceIndex < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.sourceIndex, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
- if (destinationIndex > Int32.MaxValue || destinationIndex < Int32.MinValue)
+ if (destinationIndex > int.MaxValue || destinationIndex < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.destinationIndex, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
- if (length > Int32.MaxValue || length < Int32.MinValue)
+ if (length > int.MaxValue || length < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.length, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
Array.Copy(sourceArray, (int)sourceIndex, destinationArray, (int)destinationIndex, (int)length);
private static extern ref byte GetRawArrayGeometry(Array array, out uint numComponents, out uint elementSize, out int lowerBound, out bool containsGCPointers);
// The various Get values...
- public unsafe Object GetValue(params int[] indices)
+ public unsafe object GetValue(params int[] indices)
{
if (indices == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.indices);
return TypedReference.InternalToObject(&elemref);
}
- public unsafe Object GetValue(int index)
+ public unsafe object GetValue(int index)
{
if (Rank != 1)
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_Need1DArray);
return TypedReference.InternalToObject(&elemref);
}
- public unsafe Object GetValue(int index1, int index2)
+ public unsafe object GetValue(int index1, int index2)
{
if (Rank != 2)
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_Need2DArray);
return TypedReference.InternalToObject(&elemref);
}
- public unsafe Object GetValue(int index1, int index2, int index3)
+ public unsafe object GetValue(int index1, int index2, int index3)
{
if (Rank != 3)
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_Need3DArray);
return TypedReference.InternalToObject(&elemref);
}
- public Object GetValue(long index)
+ public object GetValue(long index)
{
- if (index > Int32.MaxValue || index < Int32.MinValue)
+ if (index > int.MaxValue || index < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
return this.GetValue((int)index);
}
- public Object GetValue(long index1, long index2)
+ public object GetValue(long index1, long index2)
{
- if (index1 > Int32.MaxValue || index1 < Int32.MinValue)
+ if (index1 > int.MaxValue || index1 < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index1, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
- if (index2 > Int32.MaxValue || index2 < Int32.MinValue)
+ if (index2 > int.MaxValue || index2 < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index2, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
return this.GetValue((int)index1, (int)index2);
}
- public Object GetValue(long index1, long index2, long index3)
+ public object GetValue(long index1, long index2, long index3)
{
- if (index1 > Int32.MaxValue || index1 < Int32.MinValue)
+ if (index1 > int.MaxValue || index1 < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index1, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
- if (index2 > Int32.MaxValue || index2 < Int32.MinValue)
+ if (index2 > int.MaxValue || index2 < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index2, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
- if (index3 > Int32.MaxValue || index3 < Int32.MinValue)
+ if (index3 > int.MaxValue || index3 < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index3, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
return this.GetValue((int)index1, (int)index2, (int)index3);
}
- public Object GetValue(params long[] indices)
+ public object GetValue(params long[] indices)
{
if (indices == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.indices);
for (int i = 0; i < indices.Length; ++i)
{
long index = indices[i];
- if (index > Int32.MaxValue || index < Int32.MinValue)
+ if (index > int.MaxValue || index < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
intIndices[i] = (int)index;
}
}
- public unsafe void SetValue(Object value, int index)
+ public unsafe void SetValue(object value, int index)
{
if (Rank != 1)
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_Need1DArray);
InternalSetValue(&elemref, value);
}
- public unsafe void SetValue(Object value, int index1, int index2)
+ public unsafe void SetValue(object value, int index1, int index2)
{
if (Rank != 2)
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_Need2DArray);
InternalSetValue(&elemref, value);
}
- public unsafe void SetValue(Object value, int index1, int index2, int index3)
+ public unsafe void SetValue(object value, int index1, int index2, int index3)
{
if (Rank != 3)
ThrowHelper.ThrowArgumentException(ExceptionResource.Arg_Need3DArray);
InternalSetValue(&elemref, value);
}
- public unsafe void SetValue(Object value, params int[] indices)
+ public unsafe void SetValue(object value, params int[] indices)
{
if (indices == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.indices);
InternalSetValue(&elemref, value);
}
- public void SetValue(Object value, long index)
+ public void SetValue(object value, long index)
{
- if (index > Int32.MaxValue || index < Int32.MinValue)
+ if (index > int.MaxValue || index < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
this.SetValue(value, (int)index);
}
- public void SetValue(Object value, long index1, long index2)
+ public void SetValue(object value, long index1, long index2)
{
- if (index1 > Int32.MaxValue || index1 < Int32.MinValue)
+ if (index1 > int.MaxValue || index1 < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index1, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
- if (index2 > Int32.MaxValue || index2 < Int32.MinValue)
+ if (index2 > int.MaxValue || index2 < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index2, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
this.SetValue(value, (int)index1, (int)index2);
}
- public void SetValue(Object value, long index1, long index2, long index3)
+ public void SetValue(object value, long index1, long index2, long index3)
{
- if (index1 > Int32.MaxValue || index1 < Int32.MinValue)
+ if (index1 > int.MaxValue || index1 < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index1, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
- if (index2 > Int32.MaxValue || index2 < Int32.MinValue)
+ if (index2 > int.MaxValue || index2 < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index2, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
- if (index3 > Int32.MaxValue || index3 < Int32.MinValue)
+ if (index3 > int.MaxValue || index3 < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index3, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
this.SetValue(value, (int)index1, (int)index2, (int)index3);
}
- public void SetValue(Object value, params long[] indices)
+ public void SetValue(object value, params long[] indices)
{
if (indices == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.indices);
for (int i = 0; i < indices.Length; ++i)
{
long index = indices[i];
- if (index > Int32.MaxValue || index < Int32.MinValue)
+ if (index > int.MaxValue || index < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
intIndices[i] = (int)index;
}
// Ideally, we would like to use TypedReference.SetValue instead. Unfortunately, TypedReference.SetValue
// always throws not-supported exception
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern unsafe void InternalSetValue(void* target, Object value);
+ private static extern unsafe void InternalSetValue(void* target, object value);
public extern int Length
{
// Returns an object appropriate for synchronizing access to this
// Array.
- public Object SyncRoot
+ public object SyncRoot
{ get { return this; } }
// Is this Array read-only?
{ get { return false; } }
- Object IList.this[int index]
+ object IList.this[int index]
{
get { return GetValue(index); }
set { SetValue(value, index); }
}
- int IList.Add(Object value)
+ int IList.Add(object value)
{
ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_FixedSizeCollection);
return default;
}
- bool IList.Contains(Object value)
+ bool IList.Contains(object value)
{
return Array.IndexOf(this, value) >= this.GetLowerBound(0);
}
Array.Clear(this, this.GetLowerBound(0), this.Length);
}
- int IList.IndexOf(Object value)
+ int IList.IndexOf(object value)
{
return Array.IndexOf(this, value);
}
- void IList.Insert(int index, Object value)
+ void IList.Insert(int index, object value)
{
ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_FixedSizeCollection);
}
- void IList.Remove(Object value)
+ void IList.Remove(object value)
{
ThrowHelper.ThrowNotSupportedException(ExceptionResource.NotSupported_FixedSizeCollection);
}
// Make a new array which is a shallow copy of the original array.
//
- public Object Clone()
+ public object Clone()
{
return MemberwiseClone();
}
- Int32 IStructuralComparable.CompareTo(Object other, IComparer comparer)
+ int IStructuralComparable.CompareTo(object other, IComparer comparer)
{
if (other == null)
{
return c;
}
- Boolean IStructuralEquatable.Equals(Object other, IEqualityComparer comparer)
+ bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
{
if (other == null)
{
return false;
}
- if (Object.ReferenceEquals(this, other))
+ if (object.ReferenceEquals(this, other))
{
return true;
}
// negative result to produce the index of the first element (if any) that
// is larger than the given search value.
//
- public static int BinarySearch(Array array, Object value)
+ public static int BinarySearch(Array array, object value)
{
if (array == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
// negative result to produce the index of the first element (if any) that
// is larger than the given search value.
//
- public static int BinarySearch(Array array, int index, int length, Object value)
+ public static int BinarySearch(Array array, int index, int length, object value)
{
return BinarySearch(array, index, length, value, null);
}
// negative result to produce the index of the first element (if any) that
// is larger than the given search value.
//
- public static int BinarySearch(Array array, Object value, IComparer comparer)
+ public static int BinarySearch(Array array, object value, IComparer comparer)
{
if (array == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
// negative result to produce the index of the first element (if any) that
// is larger than the given search value.
//
- public static int BinarySearch(Array array, int index, int length, Object value, IComparer comparer)
+ public static int BinarySearch(Array array, int index, int length, object value, IComparer comparer)
{
if (array == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
int lo = index;
int hi = index + length - 1;
- Object[] objArray = array as Object[];
+ object[] objArray = array as object[];
if (objArray != null)
{
while (lo <= hi)
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern bool TrySZBinarySearch(Array sourceArray, int sourceIndex, int count, Object value, out int retVal);
+ private static extern bool TrySZBinarySearch(Array sourceArray, int sourceIndex, int count, object value, out int retVal);
public static int BinarySearch<T>(T[] array, T value)
{
public void CopyTo(Array array, long index)
{
- if (index > Int32.MaxValue || index < Int32.MinValue)
+ if (index > int.MaxValue || index < int.MinValue)
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.index, ExceptionResource.ArgumentOutOfRange_HugeArrayNotSupported);
this.CopyTo(array, (int)index);
// The array is searched forwards, and the elements of the array are
// compared to the given value using the Object.Equals method.
//
- public static int IndexOf(Array array, Object value)
+ public static int IndexOf(Array array, object value)
{
if (array == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
// elements of the array are compared to the given value using the
// Object.Equals method.
//
- public static int IndexOf(Array array, Object value, int startIndex)
+ public static int IndexOf(Array array, object value, int startIndex)
{
if (array == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
// elements of the array are compared to the given value using the
// Object.Equals method.
//
- public static int IndexOf(Array array, Object value, int startIndex, int count)
+ public static int IndexOf(Array array, object value, int startIndex, int count)
{
if (array == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
if (r)
return retVal;
- Object[] objArray = array as Object[];
+ object[] objArray = array as object[];
int endIndex = startIndex + count;
if (objArray != null)
{
{
for (int i = startIndex; i < endIndex; i++)
{
- Object obj = objArray[i];
+ object obj = objArray[i];
if (obj != null && obj.Equals(value)) return i;
}
}
{
for (int i = startIndex; i < endIndex; i++)
{
- Object obj = array.GetValue(i);
+ object obj = array.GetValue(i);
if (obj == null)
{
if (value == null) return i;
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern bool TrySZIndexOf(Array sourceArray, int sourceIndex, int count, Object value, out int retVal);
+ private static extern bool TrySZIndexOf(Array sourceArray, int sourceIndex, int count, object value, out int retVal);
// Returns the index of the last occurrence of a given value in an array.
// The array is searched backwards, and the elements of the array are
// compared to the given value using the Object.Equals method.
//
- public static int LastIndexOf(Array array, Object value)
+ public static int LastIndexOf(Array array, object value)
{
if (array == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
// startIndex and ending at index 0. The elements of the array are
// compared to the given value using the Object.Equals method.
//
- public static int LastIndexOf(Array array, Object value, int startIndex)
+ public static int LastIndexOf(Array array, object value, int startIndex)
{
if (array == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
// the array are compared to the given value using the Object.Equals
// method.
//
- public static int LastIndexOf(Array array, Object value, int startIndex, int count)
+ public static int LastIndexOf(Array array, object value, int startIndex, int count)
{
if (array == null)
ThrowHelper.ThrowArgumentNullException(ExceptionArgument.array);
if (r)
return retVal;
- Object[] objArray = array as Object[];
+ object[] objArray = array as object[];
int endIndex = startIndex - count + 1;
if (objArray != null)
{
{
for (int i = startIndex; i >= endIndex; i--)
{
- Object obj = objArray[i];
+ object obj = objArray[i];
if (obj != null && obj.Equals(value)) return i;
}
}
{
for (int i = startIndex; i >= endIndex; i--)
{
- Object obj = array.GetValue(i);
+ object obj = array.GetValue(i);
if (obj == null)
{
if (value == null) return i;
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern bool TrySZLastIndexOf(Array sourceArray, int sourceIndex, int count, Object value, out int retVal);
+ private static extern bool TrySZLastIndexOf(Array sourceArray, int sourceIndex, int count, object value, out int retVal);
// Reverses all elements of the given array. Following a call to this
if (r)
return;
- Object[] objArray = array as Object[];
+ object[] objArray = array as object[];
if (objArray != null)
{
Array.Reverse<object>(objArray, index, length);
int j = index + length - 1;
while (i < j)
{
- Object temp = array.GetValue(i);
+ object temp = array.GetValue(i);
array.SetValue(array.GetValue(j), i);
array.SetValue(temp, j);
i++;
return;
}
- Object[] objKeys = keys as Object[];
- Object[] objItems = null;
+ object[] objKeys = keys as object[];
+ object[] objItems = null;
if (objKeys != null)
- objItems = items as Object[];
+ objItems = items as object[];
if (objKeys != null && (items == null || objItems != null))
{
SorterObjectArray sorter = new SorterObjectArray(objKeys, objItems, comparer);
// Private value type used by the Sort methods.
private struct SorterObjectArray
{
- private Object[] keys;
- private Object[] items;
+ private object[] keys;
+ private object[] items;
private IComparer comparer;
- internal SorterObjectArray(Object[] keys, Object[] items, IComparer comparer)
+ internal SorterObjectArray(object[] keys, object[] items, IComparer comparer)
{
if (comparer == null) comparer = Comparer.Default;
this.keys = keys;
{
if (comparer.Compare(keys[a], keys[b]) > 0)
{
- Object temp = keys[a];
+ object temp = keys[a];
keys[a] = keys[b];
keys[b] = temp;
if (items != null)
{
- Object item = items[a];
+ object item = items[a];
items[a] = items[b];
items[b] = item;
}
private void Swap(int i, int j)
{
- Object t = keys[i];
+ object t = keys[i];
keys[i] = keys[j];
keys[j] = t;
if (items != null)
{
- Object item = items[i];
+ object item = items[i];
items[i] = items[j];
items[j] = item;
}
SwapIfGreaterWithItems(lo, hi);
SwapIfGreaterWithItems(mid, hi);
- Object pivot = keys[mid];
+ object pivot = keys[mid];
Swap(mid, hi - 1);
int left = lo, right = hi - 1; // We already partitioned lo and hi and put the pivot in hi - 1. And we pre-increment & decrement below.
private void DownHeap(int i, int n, int lo)
{
- Object d = keys[lo + i - 1];
- Object dt = (items != null) ? items[lo + i - 1] : null;
+ object d = keys[lo + i - 1];
+ object dt = (items != null) ? items[lo + i - 1] : null;
int child;
while (i <= n / 2)
{
private void InsertionSort(int lo, int hi)
{
int i, j;
- Object t, ti;
+ object t, ti;
for (i = lo; i < hi; i++)
{
j = i;
{
if (comparer.Compare(keys.GetValue(a), keys.GetValue(b)) > 0)
{
- Object key = keys.GetValue(a);
+ object key = keys.GetValue(a);
keys.SetValue(keys.GetValue(b), a);
keys.SetValue(key, b);
if (items != null)
{
- Object item = items.GetValue(a);
+ object item = items.GetValue(a);
items.SetValue(items.GetValue(b), a);
items.SetValue(item, b);
}
private void Swap(int i, int j)
{
- Object t1 = keys.GetValue(i);
+ object t1 = keys.GetValue(i);
keys.SetValue(keys.GetValue(j), i);
keys.SetValue(t1, j);
if (items != null)
{
- Object t2 = items.GetValue(i);
+ object t2 = items.GetValue(i);
items.SetValue(items.GetValue(j), i);
items.SetValue(t2, j);
}
SwapIfGreaterWithItems(lo, hi);
SwapIfGreaterWithItems(mid, hi);
- Object pivot = keys.GetValue(mid);
+ object pivot = keys.GetValue(mid);
Swap(mid, hi - 1);
int left = lo, right = hi - 1; // We already partitioned lo and hi and put the pivot in hi - 1. And we pre-increment & decrement below.
private void DownHeap(int i, int n, int lo)
{
- Object d = keys.GetValue(lo + i - 1);
- Object dt = (items != null) ? items.GetValue(lo + i - 1) : null;
+ object d = keys.GetValue(lo + i - 1);
+ object dt = (items != null) ? items.GetValue(lo + i - 1) : null;
int child;
while (i <= n / 2)
{
private void InsertionSort(int lo, int hi)
{
int i, j;
- Object t, dt;
+ object t, dt;
for (i = lo; i < hi; i++)
{
j = i;
_endIndex = array.Length;
}
- public Object Clone()
+ public object Clone()
{
return MemberwiseClone();
}
return false;
}
- public Object Current
+ public object Current
{
get
{
}
}
- public Object Clone()
+ public object Clone()
{
return MemberwiseClone();
}
return !_complete;
}
- public Object Current
+ public object Current
{
get
{
// class inherits from and return the respective ParameterInfo attributes
List<Type> disAllowMultiple = new List<Type>();
- Object[] objAttr;
+ object[] objAttr;
if (type == null)
type = typeof(Attribute);
while (baseParam != null)
{
- Object[] objAttr = baseParam.GetCustomAttributes(type, false);
+ object[] objAttr = baseParam.GetCustomAttributes(type, false);
for (int i = 0; i < objAttr.Length; i++)
{
private static AttributeUsageAttribute InternalGetAttributeUsage(Type type)
{
// Check if the custom attributes is Inheritable
- Object[] obj = type.GetCustomAttributes(typeof(AttributeUsageAttribute), false);
+ object[] obj = type.GetCustomAttributes(typeof(AttributeUsageAttribute), false);
if (obj.Length == 1)
return (AttributeUsageAttribute)obj[0];
#endregion
#region Object Overrides
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj == null)
return false;
if (thatType != thisType)
return false;
- Object thisObj = this;
- Object thisResult, thatResult;
+ object thisObj = this;
+ object thisResult, thatResult;
while (thisType != typeof(Attribute))
{
}
// Compares values of custom-attribute fields.
- private static bool AreFieldValuesEqual(Object thisValue, Object thatValue)
+ private static bool AreFieldValuesEqual(object thisValue, object thatValue)
{
if (thisValue == null && thatValue == null)
return true;
while (type != typeof(Attribute))
{
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.DeclaredOnly);
- Object vThis = null;
+ object vThis = null;
for (int i = 0; i < fields.Length; i++)
{
// Visibility check and consistency check are not necessary.
- Object fieldValue = ((RtFieldInfo)fields[i]).UnsafeGetValue(this);
+ object fieldValue = ((RtFieldInfo)fields[i]).UnsafeGetValue(this);
// The hashcode of an array ignores the contents of the array, so it can produce
// different hashcodes for arrays with the same contents.
#endregion
#region Public Virtual Members
- public virtual Object TypeId { get { return GetType(); } }
+ public virtual object TypeId { get { return GetType(); } }
- public virtual bool Match(Object obj) { return Equals(obj); }
+ public virtual bool Match(object obj) { return Equals(obj); }
#endregion
#region Public Members
#if PLATFORM_WINDOWS
// Determined optimal value for Windows.
// https://github.com/dotnet/coreclr/issues/13843
- const nuint CopyThreshold = UInt64.MaxValue;
+ const nuint CopyThreshold = ulong.MaxValue;
#else // PLATFORM_WINDOWS
// Managed code is currently faster than glibc unoptimized memmove
// TODO-ARM64-UNIX-OPT revisit when glibc optimized memmove is in Linux distros
// https://github.com/dotnet/coreclr/issues/13844
- const nuint CopyThreshold = UInt64.MaxValue;
+ const nuint CopyThreshold = ulong.MaxValue;
#endif // PLATFORM_WINDOWS
#else
const nuint CopyThreshold = 512;
#if PLATFORM_WINDOWS
// Determined optimal value for Windows.
// https://github.com/dotnet/coreclr/issues/13843
- const nuint CopyThreshold = UInt64.MaxValue;
+ const nuint CopyThreshold = ulong.MaxValue;
#else // PLATFORM_WINDOWS
// Managed code is currently faster than glibc unoptimized memmove
// TODO-ARM64-UNIX-OPT revisit when glibc optimized memmove is in Linux distros
// https://github.com/dotnet/coreclr/issues/13844
- const nuint CopyThreshold = UInt64.MaxValue;
+ const nuint CopyThreshold = ulong.MaxValue;
#endif // PLATFORM_WINDOWS
#else
const nuint CopyThreshold = 512;
}
}
- public Object SyncRoot
+ public object SyncRoot
{
get
{
// IDictionary members
- public Object this[Object key]
+ public object this[object key]
{
get
{
{
get
{
- return Array.Empty<Object>();
+ return Array.Empty<object>();
}
}
{
get
{
- return Array.Empty<Object>();
+ return Array.Empty<object>();
}
}
- public bool Contains(Object key)
+ public bool Contains(object key)
{
return false;
}
- public void Add(Object key, Object value)
+ public void Add(object key, object value)
{
if (key == null)
{
return new NodeEnumerator();
}
- public void Remove(Object key)
+ public void Remove(object key)
{
throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
}
return false;
}
- public Object Current
+ public object Current
{
get
{
// IDictionaryEnumerator members
- public Object Key
+ public object Key
{
get
{
}
}
- public Object Value
+ public object Value
{
get
{
internal class ReadOnlyDictionary<TKey, TValue> : IDictionary<TKey, TValue>, IDictionary, IReadOnlyDictionary<TKey, TValue>
{
private readonly IDictionary<TKey, TValue> m_dictionary;
- private Object m_syncRoot;
+ private object m_syncRoot;
private KeyCollection m_keys;
private ValueCollection m_values;
}
else
{
- System.Threading.Interlocked.CompareExchange<Object>(ref m_syncRoot, new Object(), null);
+ System.Threading.Interlocked.CompareExchange<object>(ref m_syncRoot, new object(), null);
}
}
return m_syncRoot;
public sealed class KeyCollection : ICollection<TKey>, ICollection, IReadOnlyCollection<TKey>
{
private readonly ICollection<TKey> m_collection;
- private Object m_syncRoot;
+ private object m_syncRoot;
internal KeyCollection(ICollection<TKey> collection)
{
}
else
{
- System.Threading.Interlocked.CompareExchange<Object>(ref m_syncRoot, new Object(), null);
+ System.Threading.Interlocked.CompareExchange<object>(ref m_syncRoot, new object(), null);
}
}
return m_syncRoot;
public sealed class ValueCollection : ICollection<TValue>, ICollection, IReadOnlyCollection<TValue>
{
private readonly ICollection<TValue> m_collection;
- private Object m_syncRoot;
+ private object m_syncRoot;
internal ValueCollection(ICollection<TValue> collection)
{
}
else
{
- System.Threading.Interlocked.CompareExchange<Object>(ref m_syncRoot, new Object(), null);
+ System.Threading.Interlocked.CompareExchange<object>(ref m_syncRoot, new object(), null);
}
}
return m_syncRoot;
// Constructs a Currency from a Decimal value.
//
- public Currency(Decimal value)
+ public Currency(decimal value)
{
- m_value = Decimal.ToCurrency(value).m_value;
+ m_value = decimal.ToCurrency(value).m_value;
}
// Constructs a Currency from a long value without scaling. The
return m_value;
}
- // Converts a Currency to a Decimal.
+ // Converts a Currency to a decimal.
//
- public static Decimal ToDecimal(Currency c)
+ public static decimal ToDecimal(Currency c)
{
- Decimal result = new Decimal();
+ decimal result = new decimal();
FCallToDecimal(ref result, c);
return result;
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void FCallToDecimal(ref Decimal result, Currency c);
+ private static extern void FCallToDecimal(ref decimal result, Currency c);
}
}
long ticks = 0;
ticks = GetSystemTimeAsFileTime();
- return new DateTime(((UInt64)(ticks + FileTimeOffset)) | KindUtc);
+ return new DateTime(((ulong)(ticks + FileTimeOffset)) | KindUtc);
}
}
[Serializable]
[System.Runtime.Versioning.NonVersionable] // This only applies to field layout
[System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public partial struct Decimal : IFormattable, IComparable, IConvertible, IComparable<Decimal>, IEquatable<Decimal>, IDeserializationCallback, ISpanFormattable
+ public partial struct Decimal : IFormattable, IComparable, IConvertible, IComparable<decimal>, IEquatable<decimal>, IDeserializationCallback, ISpanFormattable
{
// Sign mask for the flags field. A value of zero in this bit indicates a
// positive Decimal value, and a value of one in this bit indicates a
private const int ScaleShift = 16;
// The maximum power of 10 that a 32 bit integer can store
- private const Int32 MaxInt32Scale = 9;
+ private const int MaxInt32Scale = 9;
// Fast access for 10^n where n is 0-9
- private static UInt32[] Powers10 = new UInt32[] {
+ private static uint[] Powers10 = new uint[] {
1,
10,
100,
};
// Constant representing the Decimal value 0.
- public const Decimal Zero = 0m;
+ public const decimal Zero = 0m;
// Constant representing the Decimal value 1.
- public const Decimal One = 1m;
+ public const decimal One = 1m;
// Constant representing the Decimal value -1.
- public const Decimal MinusOne = -1m;
+ public const decimal MinusOne = -1m;
// Constant representing the largest possible Decimal value. The value of
// this constant is 79,228,162,514,264,337,593,543,950,335.
- public const Decimal MaxValue = 79228162514264337593543950335m;
+ public const decimal MaxValue = 79228162514264337593543950335m;
// Constant representing the smallest possible Decimal value. The value of
// this constant is -79,228,162,514,264,337,593,543,950,335.
- public const Decimal MinValue = -79228162514264337593543950335m;
+ public const decimal MinValue = -79228162514264337593543950335m;
// Constant representing the negative number that is the closest possible
// Decimal value to -0m.
- private const Decimal NearNegativeZero = -0.0000000000000000000000000001m;
+ private const decimal NearNegativeZero = -0.0000000000000000000000000001m;
// Constant representing the positive number that is the closest possible
// Decimal value to +0m.
- private const Decimal NearPositiveZero = +0.0000000000000000000000000001m;
+ private const decimal NearPositiveZero = +0.0000000000000000000000000001m;
// The lo, mid, hi, and flags fields contain the representation of the
// Decimal value. The lo, mid, and hi fields contain the 96-bit integer
// Don't remove these 2 methods below. They are required by the fx when the are dealing with Currency in their
// databases
- public static long ToOACurrency(Decimal value)
+ public static long ToOACurrency(decimal value)
{
return new Currency(value).ToOACurrency();
}
- public static Decimal FromOACurrency(long cy)
+ public static decimal FromOACurrency(long cy)
{
return Currency.ToDecimal(Currency.FromOACurrency(cy));
}
}
}
- void IDeserializationCallback.OnDeserialization(Object sender)
+ void IDeserializationCallback.OnDeserialization(object sender)
{
// OnDeserialization is called after each instance of this class is deserialized.
// This callback method performs decimal validation after being deserialized.
// positive, the result is d. If d is negative, the result
// is -d.
//
- internal static Decimal Abs(ref Decimal d)
+ internal static decimal Abs(ref decimal d)
{
- return new Decimal(d.lo, d.mid, d.hi, d.flags & ~SignMask);
+ return new decimal(d.lo, d.mid, d.hi, d.flags & ~SignMask);
}
// Adds two Decimal values.
//
- public static Decimal Add(Decimal d1, Decimal d2)
+ public static decimal Add(decimal d1, decimal d2)
{
FCallAddSub(ref d1, ref d2, DECIMAL_ADD);
return d1;
// addition or subtraction, respectively.
//
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void FCallAddSub(ref Decimal d1, ref Decimal d2, byte bSign);
+ private static extern void FCallAddSub(ref decimal d1, ref decimal d2, byte bSign);
// Rounds a Decimal to an integer value. The Decimal argument is rounded
// towards positive infinity.
- public static Decimal Ceiling(Decimal d)
+ public static decimal Ceiling(decimal d)
{
- return (-(Decimal.Floor(-d)));
+ return (-(decimal.Floor(-d)));
}
// Compares two Decimal values, returning an integer that indicates their
// relationship.
//
- public static int Compare(Decimal d1, Decimal d2)
+ public static int Compare(decimal d1, decimal d2)
{
return FCallCompare(ref d1, ref d2);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern int FCallCompare(ref Decimal d1, ref Decimal d2);
+ private static extern int FCallCompare(ref decimal d1, ref decimal d2);
// Compares this object to another object, returning an integer that
// indicates the relationship.
// null is considered to be less than any instance.
// If object is not of type Decimal, this method throws an ArgumentException.
//
- public int CompareTo(Object value)
+ public int CompareTo(object value)
{
if (value == null)
return 1;
- if (!(value is Decimal))
+ if (!(value is decimal))
throw new ArgumentException(SR.Arg_MustBeDecimal);
- Decimal other = (Decimal)value;
+ decimal other = (decimal)value;
return FCallCompare(ref this, ref other);
}
- public int CompareTo(Decimal value)
+ public int CompareTo(decimal value)
{
return FCallCompare(ref this, ref value);
}
// Divides two Decimal values.
//
- public static Decimal Divide(Decimal d1, Decimal d2)
+ public static decimal Divide(decimal d1, decimal d2)
{
FCallDivide(ref d1, ref d2);
return d1;
// of the operation.
//
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void FCallDivide(ref Decimal d1, ref Decimal d2);
+ private static extern void FCallDivide(ref decimal d1, ref decimal d2);
// Checks if this Decimal is equal to a given object. Returns true
// if the given object is a boxed Decimal and its value is equal to the
// value of this Decimal. Returns false otherwise.
//
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
- if (value is Decimal)
+ if (value is decimal)
{
- Decimal other = (Decimal)value;
+ decimal other = (decimal)value;
return FCallCompare(ref this, ref other) == 0;
}
return false;
}
- public bool Equals(Decimal value)
+ public bool Equals(decimal value)
{
return FCallCompare(ref this, ref value) == 0;
}
// Compares two Decimal values for equality. Returns true if the two
// Decimal values are equal, or false if they are not equal.
//
- public static bool Equals(Decimal d1, Decimal d2)
+ public static bool Equals(decimal d1, decimal d2)
{
return FCallCompare(ref d1, ref d2) == 0;
}
// Rounds a Decimal to an integer value. The Decimal argument is rounded
// towards negative infinity.
//
- public static Decimal Floor(Decimal d)
+ public static decimal Floor(decimal d)
{
FCallFloor(ref d);
return d;
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void FCallFloor(ref Decimal d);
+ private static extern void FCallFloor(ref decimal d);
// Converts this Decimal to a string. The resulting string consists of an
// optional minus sign ("-") followed to a sequence of digits ("0" - "9"),
// optionally followed by a decimal point (".") and another sequence of
// digits.
//
- public override String ToString()
+ public override string ToString()
{
return Number.FormatDecimal(this, null, NumberFormatInfo.CurrentInfo);
}
- public String ToString(String format)
+ public string ToString(string format)
{
return Number.FormatDecimal(this, format, NumberFormatInfo.CurrentInfo);
}
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
return Number.FormatDecimal(this, null, NumberFormatInfo.GetInstance(provider));
}
- public String ToString(String format, IFormatProvider provider)
+ public string ToString(string format, IFormatProvider provider)
{
return Number.FormatDecimal(this, format, NumberFormatInfo.GetInstance(provider));
}
// Parse also allows a currency symbol, a trailing negative sign, and
// parentheses in the number.
//
- public static Decimal Parse(String s)
+ public static decimal Parse(string s)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseDecimal(s, NumberStyles.Number, NumberFormatInfo.CurrentInfo);
}
- public static Decimal Parse(String s, NumberStyles style)
+ public static decimal Parse(string s, NumberStyles style)
{
NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseDecimal(s, style, NumberFormatInfo.CurrentInfo);
}
- public static Decimal Parse(String s, IFormatProvider provider)
+ public static decimal Parse(string s, IFormatProvider provider)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseDecimal(s, NumberStyles.Number, NumberFormatInfo.GetInstance(provider));
}
- public static Decimal Parse(String s, NumberStyles style, IFormatProvider provider)
+ public static decimal Parse(string s, NumberStyles style, IFormatProvider provider)
{
NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseDecimal(s, style, NumberFormatInfo.GetInstance(provider));
}
- public static Boolean TryParse(String s, out Decimal result)
+ public static bool TryParse(string s, out decimal result)
{
if (s == null)
{
return Number.TryParseDecimal(s, NumberStyles.Number, NumberFormatInfo.CurrentInfo, out result);
}
- public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out Decimal result)
+ public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out decimal result)
{
NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
// indicates the sign of the Decimal value, 0 meaning positive and 1
// meaning negative.
//
- public static int[] GetBits(Decimal d)
+ public static int[] GetBits(decimal d)
{
return new int[] { d.lo, d.mid, d.hi, d.flags };
}
- internal static void GetBytes(Decimal d, byte[] buffer)
+ internal static void GetBytes(decimal d, byte[] buffer)
{
Debug.Assert((buffer != null && buffer.Length >= 16), "[GetBytes]buffer != null && buffer.Length >= 16");
buffer[0] = (byte)d.lo;
int mid = ((int)buffer[4]) | ((int)buffer[5] << 8) | ((int)buffer[6] << 16) | ((int)buffer[7] << 24);
int hi = ((int)buffer[8]) | ((int)buffer[9] << 8) | ((int)buffer[10] << 16) | ((int)buffer[11] << 24);
int flags = ((int)buffer[12]) | ((int)buffer[13] << 8) | ((int)buffer[14] << 16) | ((int)buffer[15] << 24);
- return new Decimal(lo, mid, hi, flags);
+ return new decimal(lo, mid, hi, flags);
}
// This method does a 'raw' and 'unchecked' addition of a UInt32 to a Decimal in place.
// ingores the sign and scale. This means that it is not equivalent to just adding
// that number, as the sign and scale are effectively applied to the UInt32 value also.
// 'unchecked' means that it does not fail if you overflow the 96 bit value.
- private static void InternalAddUInt32RawUnchecked(ref Decimal value, UInt32 i)
+ private static void InternalAddUInt32RawUnchecked(ref decimal value, uint i)
{
- UInt32 v;
- UInt32 sum;
- v = (UInt32)value.lo;
+ uint v;
+ uint sum;
+ v = (uint)value.lo;
sum = v + i;
- value.lo = (Int32)sum;
+ value.lo = (int)sum;
if (sum < v || sum < i)
{
- v = (UInt32)value.mid;
+ v = (uint)value.mid;
sum = v + 1;
- value.mid = (Int32)sum;
+ value.mid = (int)sum;
if (sum < v || sum < 1)
{
- value.hi = (Int32)((UInt32)value.hi + 1);
+ value.hi = (int)((uint)value.hi + 1);
}
}
}
// This method does an in-place division of a decimal by a UInt32, returning the remainder.
// Although it does not operate on the sign or scale, this does not result in any
// caveat for the result. It is equivalent to dividing by that number.
- private static UInt32 InternalDivRemUInt32(ref Decimal value, UInt32 divisor)
+ private static uint InternalDivRemUInt32(ref decimal value, uint divisor)
{
- UInt32 remainder = 0;
- UInt64 n;
+ uint remainder = 0;
+ ulong n;
if (value.hi != 0)
{
- n = ((UInt32)value.hi);
- value.hi = (Int32)((UInt32)(n / divisor));
- remainder = (UInt32)(n % divisor);
+ n = ((uint)value.hi);
+ value.hi = (int)((uint)(n / divisor));
+ remainder = (uint)(n % divisor);
}
if (value.mid != 0 || remainder != 0)
{
- n = ((UInt64)remainder << 32) | (UInt32)value.mid;
- value.mid = (Int32)((UInt32)(n / divisor));
- remainder = (UInt32)(n % divisor);
+ n = ((ulong)remainder << 32) | (uint)value.mid;
+ value.mid = (int)((uint)(n / divisor));
+ remainder = (uint)(n % divisor);
}
if (value.lo != 0 || remainder != 0)
{
- n = ((UInt64)remainder << 32) | (UInt32)value.lo;
- value.lo = (Int32)((UInt32)(n / divisor));
- remainder = (UInt32)(n % divisor);
+ n = ((ulong)remainder << 32) | (uint)value.lo;
+ value.lo = (int)((uint)(n / divisor));
+ remainder = (uint)(n % divisor);
}
return remainder;
}
// Does an in-place round the specified number of digits, rounding mid-point values
// away from zero
- private static void InternalRoundFromZero(ref Decimal d, int decimalCount)
+ private static void InternalRoundFromZero(ref decimal d, int decimalCount)
{
- Int32 scale = (d.flags & ScaleMask) >> ScaleShift;
- Int32 scaleDifference = scale - decimalCount;
+ int scale = (d.flags & ScaleMask) >> ScaleShift;
+ int scaleDifference = scale - decimalCount;
if (scaleDifference <= 0)
{
return;
}
// Divide the value by 10^scaleDifference
- UInt32 lastRemainder;
- UInt32 lastDivisor;
+ uint lastRemainder;
+ uint lastDivisor;
do
{
- Int32 diffChunk = (scaleDifference > MaxInt32Scale) ? MaxInt32Scale : scaleDifference;
+ int diffChunk = (scaleDifference > MaxInt32Scale) ? MaxInt32Scale : scaleDifference;
lastDivisor = Powers10[diffChunk];
lastRemainder = InternalDivRemUInt32(ref d, lastDivisor);
scaleDifference -= diffChunk;
// Returns the larger of two Decimal values.
//
- internal static Decimal Max(ref Decimal d1, ref Decimal d2)
+ internal static decimal Max(ref decimal d1, ref decimal d2)
{
return FCallCompare(ref d1, ref d2) >= 0 ? d1 : d2;
}
// Returns the smaller of two Decimal values.
//
- internal static Decimal Min(ref Decimal d1, ref Decimal d2)
+ internal static decimal Min(ref decimal d1, ref decimal d2)
{
return FCallCompare(ref d1, ref d2) < 0 ? d1 : d2;
}
- public static Decimal Remainder(Decimal d1, Decimal d2)
+ public static decimal Remainder(decimal d1, decimal d2)
{
// OleAut doesn't provide a VarDecMod.
}
// Formula: d1 - (RoundTowardsZero(d1 / d2) * d2)
- Decimal dividedResult = Truncate(d1 / d2);
- Decimal multipliedResult = dividedResult * d2;
- Decimal result = d1 - multipliedResult;
+ decimal dividedResult = Truncate(d1 / d2);
+ decimal multipliedResult = dividedResult * d2;
+ decimal result = d1 - multipliedResult;
// See if the result has crossed 0
if ((d1.flags & SignMask) != (result.flags & SignMask))
{
// Multiplies two Decimal values.
//
- public static Decimal Multiply(Decimal d1, Decimal d2)
+ public static decimal Multiply(decimal d1, decimal d2)
{
FCallMultiply(ref d1, ref d2);
return d1;
// of the operation.
//
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void FCallMultiply(ref Decimal d1, ref Decimal d2);
+ private static extern void FCallMultiply(ref decimal d1, ref decimal d2);
// Returns the negated value of the given Decimal. If d is non-zero,
// the result is -d. If d is zero, the result is zero.
//
- public static Decimal Negate(Decimal d)
+ public static decimal Negate(decimal d)
{
- return new Decimal(d.lo, d.mid, d.hi, d.flags ^ SignMask);
+ return new decimal(d.lo, d.mid, d.hi, d.flags ^ SignMask);
}
// Rounds a Decimal value to a given number of decimal places. The value
// By default a mid-point value is rounded to the nearest even number. If the mode is
// passed in, it can also round away from zero.
- public static Decimal Round(Decimal d)
+ public static decimal Round(decimal d)
{
return Round(d, 0);
}
- public static Decimal Round(Decimal d, int decimals)
+ public static decimal Round(decimal d, int decimals)
{
FCallRound(ref d, decimals);
return d;
}
- public static Decimal Round(Decimal d, MidpointRounding mode)
+ public static decimal Round(decimal d, MidpointRounding mode)
{
return Round(d, 0, mode);
}
- public static Decimal Round(Decimal d, int decimals, MidpointRounding mode)
+ public static decimal Round(decimal d, int decimals, MidpointRounding mode)
{
if ((decimals < 0) || (decimals > 28))
throw new ArgumentOutOfRangeException(nameof(decimals), SR.ArgumentOutOfRange_DecimalRound);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void FCallRound(ref Decimal d, int decimals);
+ private static extern void FCallRound(ref decimal d, int decimals);
internal static int Sign(ref decimal d) => (d.lo | d.mid | d.hi) == 0 ? 0 : (d.flags >> 31) | 1;
// Subtracts two Decimal values.
//
- public static Decimal Subtract(Decimal d1, Decimal d2)
+ public static decimal Subtract(decimal d1, decimal d2)
{
FCallAddSub(ref d1, ref d2, DECIMAL_NEG);
return d1;
// towards zero to the nearest integer value, and the result of this
// operation is returned as a byte.
//
- public static byte ToByte(Decimal value)
+ public static byte ToByte(decimal value)
{
uint temp;
try
{
throw new OverflowException(SR.Overflow_Byte, e);
}
- if (temp < Byte.MinValue || temp > Byte.MaxValue) throw new OverflowException(SR.Overflow_Byte);
+ if (temp < byte.MinValue || temp > byte.MaxValue) throw new OverflowException(SR.Overflow_Byte);
return (byte)temp;
}
// operation is returned as a byte.
//
[CLSCompliant(false)]
- public static sbyte ToSByte(Decimal value)
+ public static sbyte ToSByte(decimal value)
{
int temp;
try
{
throw new OverflowException(SR.Overflow_SByte, e);
}
- if (temp < SByte.MinValue || temp > SByte.MaxValue) throw new OverflowException(SR.Overflow_SByte);
+ if (temp < sbyte.MinValue || temp > sbyte.MaxValue) throw new OverflowException(SR.Overflow_SByte);
return (sbyte)temp;
}
// rounded towards zero to the nearest integer value, and the result of
// this operation is returned as a short.
//
- public static short ToInt16(Decimal value)
+ public static short ToInt16(decimal value)
{
int temp;
try
{
throw new OverflowException(SR.Overflow_Int16, e);
}
- if (temp < Int16.MinValue || temp > Int16.MaxValue) throw new OverflowException(SR.Overflow_Int16);
+ if (temp < short.MinValue || temp > short.MaxValue) throw new OverflowException(SR.Overflow_Int16);
return (short)temp;
}
// has fewer significant digits than a Decimal, this operation may
// produce round-off errors.
//
- internal static Currency ToCurrency(Decimal d)
+ internal static Currency ToCurrency(decimal d)
{
Currency result = new Currency();
FCallToCurrency(ref result, d);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void FCallToCurrency(ref Currency result, Decimal d);
+ private static extern void FCallToCurrency(ref Currency result, decimal d);
// Converts a Decimal to a double. Since a double has fewer significant
// digits than a Decimal, this operation may produce round-off errors.
//
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern double ToDouble(Decimal d);
+ public static extern double ToDouble(decimal d);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern int FCallToInt32(Decimal d);
+ internal static extern int FCallToInt32(decimal d);
// Converts a Decimal to an integer. The Decimal value is rounded towards
// zero to the nearest integer value, and the result of this operation is
// returned as an integer.
//
- public static int ToInt32(Decimal d)
+ public static int ToInt32(decimal d)
{
if ((d.flags & ScaleMask) != 0) FCallTruncate(ref d);
if (d.hi == 0 && d.mid == 0)
// to the nearest integer value, and the result of this operation is
// returned as a long.
//
- public static long ToInt64(Decimal d)
+ public static long ToInt64(decimal d)
{
if ((d.flags & ScaleMask) != 0) FCallTruncate(ref d);
if (d.hi == 0)
// result of this operation is returned as an ushort.
//
[CLSCompliant(false)]
- public static ushort ToUInt16(Decimal value)
+ public static ushort ToUInt16(decimal value)
{
uint temp;
try
{
throw new OverflowException(SR.Overflow_UInt16, e);
}
- if (temp < UInt16.MinValue || temp > UInt16.MaxValue) throw new OverflowException(SR.Overflow_UInt16);
+ if (temp < ushort.MinValue || temp > ushort.MaxValue) throw new OverflowException(SR.Overflow_UInt16);
return (ushort)temp;
}
// result of this operation is returned as an unsigned integer.
//
[CLSCompliant(false)]
- public static uint ToUInt32(Decimal d)
+ public static uint ToUInt32(decimal d)
{
if ((d.flags & ScaleMask) != 0) FCallTruncate(ref d);
if (d.hi == 0 && d.mid == 0)
// result of this operation is returned as a long.
//
[CLSCompliant(false)]
- public static ulong ToUInt64(Decimal d)
+ public static ulong ToUInt64(decimal d)
{
if ((d.flags & ScaleMask) != 0) FCallTruncate(ref d);
if (d.hi == 0)
// digits than a Decimal, this operation may produce round-off errors.
//
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern float ToSingle(Decimal d);
+ public static extern float ToSingle(decimal d);
// Truncates a Decimal to an integer value. The Decimal argument is rounded
// towards zero to the nearest integer value, corresponding to removing all
// digits after the decimal point.
//
- public static Decimal Truncate(Decimal d)
+ public static decimal Truncate(decimal d)
{
FCallTruncate(ref d);
return d;
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void FCallTruncate(ref Decimal d);
+ private static extern void FCallTruncate(ref decimal d);
- public static implicit operator Decimal(byte value)
+ public static implicit operator decimal(byte value)
{
- return new Decimal(value);
+ return new decimal(value);
}
[CLSCompliant(false)]
- public static implicit operator Decimal(sbyte value)
+ public static implicit operator decimal(sbyte value)
{
- return new Decimal(value);
+ return new decimal(value);
}
- public static implicit operator Decimal(short value)
+ public static implicit operator decimal(short value)
{
- return new Decimal(value);
+ return new decimal(value);
}
[CLSCompliant(false)]
- public static implicit operator Decimal(ushort value)
+ public static implicit operator decimal(ushort value)
{
- return new Decimal(value);
+ return new decimal(value);
}
- public static implicit operator Decimal(char value)
+ public static implicit operator decimal(char value)
{
- return new Decimal(value);
+ return new decimal(value);
}
- public static implicit operator Decimal(int value)
+ public static implicit operator decimal(int value)
{
- return new Decimal(value);
+ return new decimal(value);
}
[CLSCompliant(false)]
- public static implicit operator Decimal(uint value)
+ public static implicit operator decimal(uint value)
{
- return new Decimal(value);
+ return new decimal(value);
}
- public static implicit operator Decimal(long value)
+ public static implicit operator decimal(long value)
{
- return new Decimal(value);
+ return new decimal(value);
}
[CLSCompliant(false)]
- public static implicit operator Decimal(ulong value)
+ public static implicit operator decimal(ulong value)
{
- return new Decimal(value);
+ return new decimal(value);
}
- public static explicit operator Decimal(float value)
+ public static explicit operator decimal(float value)
{
- return new Decimal(value);
+ return new decimal(value);
}
- public static explicit operator Decimal(double value)
+ public static explicit operator decimal(double value)
{
- return new Decimal(value);
+ return new decimal(value);
}
- public static explicit operator byte(Decimal value)
+ public static explicit operator byte(decimal value)
{
return ToByte(value);
}
[CLSCompliant(false)]
- public static explicit operator sbyte(Decimal value)
+ public static explicit operator sbyte(decimal value)
{
return ToSByte(value);
}
- public static explicit operator char(Decimal value)
+ public static explicit operator char(decimal value)
{
- UInt16 temp;
+ ushort temp;
try
{
temp = ToUInt16(value);
return (char)temp;
}
- public static explicit operator short(Decimal value)
+ public static explicit operator short(decimal value)
{
return ToInt16(value);
}
[CLSCompliant(false)]
- public static explicit operator ushort(Decimal value)
+ public static explicit operator ushort(decimal value)
{
return ToUInt16(value);
}
- public static explicit operator int(Decimal value)
+ public static explicit operator int(decimal value)
{
return ToInt32(value);
}
[CLSCompliant(false)]
- public static explicit operator uint(Decimal value)
+ public static explicit operator uint(decimal value)
{
return ToUInt32(value);
}
- public static explicit operator long(Decimal value)
+ public static explicit operator long(decimal value)
{
return ToInt64(value);
}
[CLSCompliant(false)]
- public static explicit operator ulong(Decimal value)
+ public static explicit operator ulong(decimal value)
{
return ToUInt64(value);
}
- public static explicit operator float(Decimal value)
+ public static explicit operator float(decimal value)
{
return ToSingle(value);
}
- public static explicit operator double(Decimal value)
+ public static explicit operator double(decimal value)
{
return ToDouble(value);
}
- public static Decimal operator +(Decimal d)
+ public static decimal operator +(decimal d)
{
return d;
}
- public static Decimal operator -(Decimal d)
+ public static decimal operator -(decimal d)
{
return Negate(d);
}
- public static Decimal operator ++(Decimal d)
+ public static decimal operator ++(decimal d)
{
return Add(d, One);
}
- public static Decimal operator --(Decimal d)
+ public static decimal operator --(decimal d)
{
return Subtract(d, One);
}
- public static Decimal operator +(Decimal d1, Decimal d2)
+ public static decimal operator +(decimal d1, decimal d2)
{
FCallAddSub(ref d1, ref d2, DECIMAL_ADD);
return d1;
}
- public static Decimal operator -(Decimal d1, Decimal d2)
+ public static decimal operator -(decimal d1, decimal d2)
{
FCallAddSub(ref d1, ref d2, DECIMAL_NEG);
return d1;
}
- public static Decimal operator *(Decimal d1, Decimal d2)
+ public static decimal operator *(decimal d1, decimal d2)
{
FCallMultiply(ref d1, ref d2);
return d1;
}
- public static Decimal operator /(Decimal d1, Decimal d2)
+ public static decimal operator /(decimal d1, decimal d2)
{
FCallDivide(ref d1, ref d2);
return d1;
}
- public static Decimal operator %(Decimal d1, Decimal d2)
+ public static decimal operator %(decimal d1, decimal d2)
{
return Remainder(d1, d2);
}
- public static bool operator ==(Decimal d1, Decimal d2)
+ public static bool operator ==(decimal d1, decimal d2)
{
return FCallCompare(ref d1, ref d2) == 0;
}
- public static bool operator !=(Decimal d1, Decimal d2)
+ public static bool operator !=(decimal d1, decimal d2)
{
return FCallCompare(ref d1, ref d2) != 0;
}
- public static bool operator <(Decimal d1, Decimal d2)
+ public static bool operator <(decimal d1, decimal d2)
{
return FCallCompare(ref d1, ref d2) < 0;
}
- public static bool operator <=(Decimal d1, Decimal d2)
+ public static bool operator <=(decimal d1, decimal d2)
{
return FCallCompare(ref d1, ref d2) <= 0;
}
- public static bool operator >(Decimal d1, Decimal d2)
+ public static bool operator >(decimal d1, decimal d2)
{
return FCallCompare(ref d1, ref d2) > 0;
}
- public static bool operator >=(Decimal d1, Decimal d2)
+ public static bool operator >=(decimal d1, decimal d2)
{
return FCallCompare(ref d1, ref d2) >= 0;
}
return Convert.ToDouble(this);
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
return this;
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Decimal", "DateTime"));
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
public abstract class Delegate : ICloneable, ISerializable
{
// _target is the object we will invoke on
- internal Object _target;
+ internal object _target;
// MethodBase, either cached after first request or assigned from a DynamicMethod
// For open delegates to collectible types, this may be a LoaderAllocator object
- internal Object _methodBase;
+ internal object _methodBase;
// _methodPtr is a pointer to the method we will invoke
// It could be a small thunk if this is a static or UM call
// This constructor is called from the class generated by the
// compiler generated code
- protected Delegate(Object target, String method)
+ protected Delegate(object target, string method)
{
if (target == null)
throw new ArgumentNullException(nameof(target));
// This constructor is called from a class to generate a
// delegate based upon a static method name and the Type object
// for the class defining the method.
- protected unsafe Delegate(Type target, String method)
+ protected unsafe Delegate(Type target, string method)
{
if (target == null)
throw new ArgumentNullException(nameof(target));
{
}
- public Object DynamicInvoke(params Object[] args)
+ public object DynamicInvoke(params object[] args)
{
// Theoretically we should set up a LookForMyCaller stack mark here and pass that along.
// But to maintain backward compatibility we can't switch to calling an
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj == null || !InternalEqualTypes(this, obj))
return false;
public static Delegate Combine(Delegate a, Delegate b)
{
- if ((Object)a == null) // cast to object for a more efficient test
+ if ((object)a == null) // cast to object for a more efficient test
return b;
return a.CombineImpl(b);
return (MethodInfo)_methodBase;
}
- public Object Target
+ public object Target
{
get
{
}
- public virtual Object Clone()
+ public virtual object Clone()
{
return MemberwiseClone();
}
// V1 API.
- public static Delegate CreateDelegate(Type type, Object target, String method)
+ public static Delegate CreateDelegate(Type type, object target, string method)
{
return CreateDelegate(type, target, method, false, true);
}
// V1 API.
- public static Delegate CreateDelegate(Type type, Object target, String method, bool ignoreCase)
+ public static Delegate CreateDelegate(Type type, object target, string method, bool ignoreCase)
{
return CreateDelegate(type, target, method, ignoreCase, true);
}
// V1 API.
- public static Delegate CreateDelegate(Type type, Object target, String method, bool ignoreCase, bool throwOnBindFailure)
+ public static Delegate CreateDelegate(Type type, object target, string method, bool ignoreCase, bool throwOnBindFailure)
{
if (type == null)
throw new ArgumentNullException(nameof(type));
}
// V1 API.
- public static Delegate CreateDelegate(Type type, Type target, String method)
+ public static Delegate CreateDelegate(Type type, Type target, string method)
{
return CreateDelegate(type, target, method, false, true);
}
// V1 API.
- public static Delegate CreateDelegate(Type type, Type target, String method, bool ignoreCase)
+ public static Delegate CreateDelegate(Type type, Type target, string method, bool ignoreCase)
{
return CreateDelegate(type, target, method, ignoreCase, true);
}
// V1 API.
- public static Delegate CreateDelegate(Type type, Type target, String method, bool ignoreCase, bool throwOnBindFailure)
+ public static Delegate CreateDelegate(Type type, Type target, string method, bool ignoreCase, bool throwOnBindFailure)
{
if (type == null)
throw new ArgumentNullException(nameof(type));
}
// V2 API.
- public static Delegate CreateDelegate(Type type, Object firstArgument, MethodInfo method)
+ public static Delegate CreateDelegate(Type type, object firstArgument, MethodInfo method)
{
return CreateDelegate(type, firstArgument, method, true);
}
// V2 API.
- public static Delegate CreateDelegate(Type type, Object firstArgument, MethodInfo method, bool throwOnBindFailure)
+ public static Delegate CreateDelegate(Type type, object firstArgument, MethodInfo method, bool throwOnBindFailure)
{
// Validate the parameters.
if (type == null)
public static bool operator ==(Delegate d1, Delegate d2)
{
- if ((Object)d1 == null)
- return (Object)d2 == null;
+ if ((object)d1 == null)
+ return (object)d2 == null;
return d1.Equals(d2);
}
public static bool operator !=(Delegate d1, Delegate d2)
{
- if ((Object)d1 == null)
- return (Object)d2 != null;
+ if ((object)d1 == null)
+ return (object)d2 != null;
return !d1.Equals(d2);
}
// V2 internal API.
// This is Critical because it skips the security check when creating the delegate.
- internal static unsafe Delegate CreateDelegateNoSecurityCheck(Type type, Object target, RuntimeMethodHandle method)
+ internal static unsafe Delegate CreateDelegateNoSecurityCheck(Type type, object target, RuntimeMethodHandle method)
{
// Validate the parameters.
if (type == null)
}
// Caution: this method is intended for deserialization only, no security checks are performed.
- internal static Delegate CreateDelegateNoSecurityCheck(RuntimeType type, Object firstArgument, MethodInfo method)
+ internal static Delegate CreateDelegateNoSecurityCheck(RuntimeType type, object firstArgument, MethodInfo method)
{
// Validate the parameters.
if (type == null)
return CreateDelegate(type, method, true);
}
- internal static Delegate CreateDelegateInternal(RuntimeType rtType, RuntimeMethodInfo rtMethod, Object firstArgument, DelegateBindingFlags flags)
+ internal static Delegate CreateDelegateInternal(RuntimeType rtType, RuntimeMethodInfo rtMethod, object firstArgument, DelegateBindingFlags flags)
{
Delegate d = InternalAlloc(rtType);
//
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private extern bool BindToMethodName(Object target, RuntimeType methodType, String method, DelegateBindingFlags flags);
+ private extern bool BindToMethodName(object target, RuntimeType methodType, string method, DelegateBindingFlags flags);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private extern bool BindToMethodInfo(Object target, IRuntimeMethodInfo method, RuntimeType methodType, DelegateBindingFlags flags);
+ private extern bool BindToMethodInfo(object target, IRuntimeMethodInfo method, RuntimeType methodType, DelegateBindingFlags flags);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private static extern MulticastDelegate InternalAlloc(RuntimeType type);
// Used by the ctor. Do not call directly.
// The name of this function will appear in managed stacktraces as delegate constructor.
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private extern void DelegateConstruct(Object target, IntPtr slot);
+ private extern void DelegateConstruct(object target, IntPtr slot);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal extern IntPtr GetMulticastInvoke();
internal static extern bool InternalEqualMethodHandles(Delegate left, Delegate right);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal extern IntPtr AdjustTarget(Object target, IntPtr methodPtr);
+ internal extern IntPtr AdjustTarget(object target, IntPtr methodPtr);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal extern IntPtr GetCallStub(IntPtr methodPtr);
- internal virtual Object GetTarget()
+ internal virtual object GetTarget()
{
return (_methodPtrAux == IntPtr.Zero) ? _target : null;
}
[AttributeUsage(AttributeTargets.Field)]
public sealed class ContractPublicPropertyNameAttribute : Attribute
{
- private String _publicName;
+ private string _publicName;
- public ContractPublicPropertyNameAttribute(String name)
+ public ContractPublicPropertyNameAttribute(string name)
{
_publicName = name;
}
- public String Name
+ public string Name
{
get { return _publicName; }
}
[Conditional("CONTRACTS_FULL")]
public sealed class ContractOptionAttribute : Attribute
{
- private String _category;
- private String _setting;
+ private string _category;
+ private string _setting;
private bool _enabled;
- private String _value;
+ private string _value;
- public ContractOptionAttribute(String category, String setting, bool enabled)
+ public ContractOptionAttribute(string category, string setting, bool enabled)
{
_category = category;
_setting = setting;
_enabled = enabled;
}
- public ContractOptionAttribute(String category, String setting, String value)
+ public ContractOptionAttribute(string category, string setting, string value)
{
_category = category;
_setting = setting;
_value = value;
}
- public String Category
+ public string Category
{
get { return _category; }
}
- public String Setting
+ public string Setting
{
get { return _setting; }
}
get { return _enabled; }
}
- public String Value
+ public string Value
{
get { return _value; }
}
[Pure]
[Conditional("DEBUG")]
[Conditional("CONTRACTS_FULL")]
- public static void Assume(bool condition, String userMessage)
+ public static void Assume(bool condition, string userMessage)
{
if (!condition)
{
[Pure]
[Conditional("DEBUG")]
[Conditional("CONTRACTS_FULL")]
- public static void Assert(bool condition, String userMessage)
+ public static void Assert(bool condition, string userMessage)
{
if (!condition)
ReportFailure(ContractFailureKind.Assert, userMessage, null, null);
/// </remarks>
[Pure]
[Conditional("CONTRACTS_FULL")]
- public static void Requires(bool condition, String userMessage)
+ public static void Requires(bool condition, string userMessage)
{
AssertMustUseRewriter(ContractFailureKind.Precondition, "Requires");
}
/// Use this form when you want to throw a particular exception.
/// </remarks>
[Pure]
- public static void Requires<TException>(bool condition, String userMessage) where TException : Exception
+ public static void Requires<TException>(bool condition, string userMessage) where TException : Exception
{
AssertMustUseRewriter(ContractFailureKind.Precondition, "Requires<TException>");
}
/// </remarks>
[Pure]
[Conditional("CONTRACTS_FULL")]
- public static void Ensures(bool condition, String userMessage)
+ public static void Ensures(bool condition, string userMessage)
{
AssertMustUseRewriter(ContractFailureKind.Postcondition, "Ensures");
}
/// </remarks>
[Pure]
[Conditional("CONTRACTS_FULL")]
- public static void EnsuresOnThrow<TException>(bool condition, String userMessage) where TException : Exception
+ public static void EnsuresOnThrow<TException>(bool condition, string userMessage) where TException : Exception
{
AssertMustUseRewriter(ContractFailureKind.PostconditionOnException, "EnsuresOnThrow");
}
/// </remarks>
[Pure]
[Conditional("CONTRACTS_FULL")]
- public static void Invariant(bool condition, String userMessage)
+ public static void Invariant(bool condition, string userMessage)
{
AssertMustUseRewriter(ContractFailureKind.Invariant, "Invariant");
}
#region Private fields
private static volatile EventHandler<ContractFailedEventArgs> contractFailedEvent;
- private static readonly Object lockObject = new Object();
+ private static readonly object lockObject = new object();
internal const int COR_E_CODECONTRACTFAILED = unchecked((int)0x80131542);
}
}
- private static readonly object s_ForLock = new Object();
+ private static readonly object s_ForLock = new object();
private static void WriteCore(string message)
{
{
#pragma warning disable 169
#pragma warning disable 414 // Field is not used from managed.
- private Object _objectReference;
+ private object _objectReference;
#pragma warning restore 414
#pragma warning restore 169
}
}
// Define an EventPipeEvent handle.
- unsafe IntPtr IEventProvider.DefineEventHandle(uint eventID, string eventName, Int64 keywords, uint eventVersion, uint level, byte *pMetadata, uint metadataLength)
+ unsafe IntPtr IEventProvider.DefineEventHandle(uint eventID, string eventName, long keywords, uint eventVersion, uint level, byte *pMetadata, uint metadataLength)
{
IntPtr eventHandlePtr = EventPipeInternal.DefineEvent(m_provHandle, eventID, keywords, eventVersion, level, pMetadata, metadataLength);
return eventHandlePtr;
// ResourceManager Event Definitions
[Event(1, Level = EventLevel.Informational, Keywords = Keywords.Loader)]
- public void ResourceManagerLookupStarted(String baseName, String mainAssemblyName, String cultureName)
+ public void ResourceManagerLookupStarted(string baseName, string mainAssemblyName, string cultureName)
{
WriteEvent(1, baseName, mainAssemblyName, cultureName);
}
[Event(2, Level = EventLevel.Informational, Keywords = Keywords.Loader)]
- public void ResourceManagerLookingForResourceSet(String baseName, String mainAssemblyName, String cultureName)
+ public void ResourceManagerLookingForResourceSet(string baseName, string mainAssemblyName, string cultureName)
{
if (IsEnabled())
WriteEvent(2, baseName, mainAssemblyName, cultureName);
}
[Event(3, Level = EventLevel.Informational, Keywords = Keywords.Loader)]
- public void ResourceManagerFoundResourceSetInCache(String baseName, String mainAssemblyName, String cultureName)
+ public void ResourceManagerFoundResourceSetInCache(string baseName, string mainAssemblyName, string cultureName)
{
if (IsEnabled())
WriteEvent(3, baseName, mainAssemblyName, cultureName);
// the cache. This can happen if you have an assembly load callback that called into this
// instance of the ResourceManager.
[Event(4, Level = EventLevel.Warning, Keywords = Keywords.Loader)]
- public void ResourceManagerFoundResourceSetInCacheUnexpected(String baseName, String mainAssemblyName, String cultureName)
+ public void ResourceManagerFoundResourceSetInCacheUnexpected(string baseName, string mainAssemblyName, string cultureName)
{
if (IsEnabled())
WriteEvent(4, baseName, mainAssemblyName, cultureName);
// manifest resource stream lookup succeeded
[Event(5, Level = EventLevel.Informational, Keywords = Keywords.Loader)]
- public void ResourceManagerStreamFound(String baseName, String mainAssemblyName, String cultureName, String loadedAssemblyName, String resourceFileName)
+ public void ResourceManagerStreamFound(string baseName, string mainAssemblyName, string cultureName, string loadedAssemblyName, string resourceFileName)
{
if (IsEnabled())
WriteEvent(5, baseName, mainAssemblyName, cultureName, loadedAssemblyName, resourceFileName);
// manifest resource stream lookup failed
[Event(6, Level = EventLevel.Warning, Keywords = Keywords.Loader)]
- public void ResourceManagerStreamNotFound(String baseName, String mainAssemblyName, String cultureName, String loadedAssemblyName, String resourceFileName)
+ public void ResourceManagerStreamNotFound(string baseName, string mainAssemblyName, string cultureName, string loadedAssemblyName, string resourceFileName)
{
if (IsEnabled())
WriteEvent(6, baseName, mainAssemblyName, cultureName, loadedAssemblyName, resourceFileName);
}
[Event(7, Level = EventLevel.Informational, Keywords = Keywords.Loader)]
- public void ResourceManagerGetSatelliteAssemblySucceeded(String baseName, String mainAssemblyName, String cultureName, String assemblyName)
+ public void ResourceManagerGetSatelliteAssemblySucceeded(string baseName, string mainAssemblyName, string cultureName, string assemblyName)
{
if (IsEnabled())
WriteEvent(7, baseName, mainAssemblyName, cultureName, assemblyName);
}
[Event(8, Level = EventLevel.Warning, Keywords = Keywords.Loader)]
- public void ResourceManagerGetSatelliteAssemblyFailed(String baseName, String mainAssemblyName, String cultureName, String assemblyName)
+ public void ResourceManagerGetSatelliteAssemblyFailed(string baseName, string mainAssemblyName, string cultureName, string assemblyName)
{
if (IsEnabled())
WriteEvent(8, baseName, mainAssemblyName, cultureName, assemblyName);
}
[Event(9, Level = EventLevel.Informational, Keywords = Keywords.Loader)]
- public void ResourceManagerCaseInsensitiveResourceStreamLookupSucceeded(String baseName, String mainAssemblyName, String assemblyName, String resourceFileName)
+ public void ResourceManagerCaseInsensitiveResourceStreamLookupSucceeded(string baseName, string mainAssemblyName, string assemblyName, string resourceFileName)
{
if (IsEnabled())
WriteEvent(9, baseName, mainAssemblyName, assemblyName, resourceFileName);
}
[Event(10, Level = EventLevel.Warning, Keywords = Keywords.Loader)]
- public void ResourceManagerCaseInsensitiveResourceStreamLookupFailed(String baseName, String mainAssemblyName, String assemblyName, String resourceFileName)
+ public void ResourceManagerCaseInsensitiveResourceStreamLookupFailed(string baseName, string mainAssemblyName, string assemblyName, string resourceFileName)
{
if (IsEnabled())
WriteEvent(10, baseName, mainAssemblyName, assemblyName, resourceFileName);
// Could not access the manifest resource the assembly
[Event(11, Level = EventLevel.Error, Keywords = Keywords.Loader)]
- public void ResourceManagerManifestResourceAccessDenied(String baseName, String mainAssemblyName, String assemblyName, String canonicalName)
+ public void ResourceManagerManifestResourceAccessDenied(string baseName, string mainAssemblyName, string assemblyName, string canonicalName)
{
if (IsEnabled())
WriteEvent(11, baseName, mainAssemblyName, assemblyName, canonicalName);
// Neutral resources are sufficient for this culture. Skipping satellites
[Event(12, Level = EventLevel.Informational, Keywords = Keywords.Loader)]
- public void ResourceManagerNeutralResourcesSufficient(String baseName, String mainAssemblyName, String cultureName)
+ public void ResourceManagerNeutralResourcesSufficient(string baseName, string mainAssemblyName, string cultureName)
{
if (IsEnabled())
WriteEvent(12, baseName, mainAssemblyName, cultureName);
}
[Event(13, Level = EventLevel.Warning, Keywords = Keywords.Loader)]
- public void ResourceManagerNeutralResourceAttributeMissing(String mainAssemblyName)
+ public void ResourceManagerNeutralResourceAttributeMissing(string mainAssemblyName)
{
if (IsEnabled())
WriteEvent(13, mainAssemblyName);
}
[Event(14, Level = EventLevel.Informational, Keywords = Keywords.Loader)]
- public void ResourceManagerCreatingResourceSet(String baseName, String mainAssemblyName, String cultureName, String fileName)
+ public void ResourceManagerCreatingResourceSet(string baseName, string mainAssemblyName, string cultureName, string fileName)
{
if (IsEnabled())
WriteEvent(14, baseName, mainAssemblyName, cultureName, fileName);
}
[Event(15, Level = EventLevel.Informational, Keywords = Keywords.Loader)]
- public void ResourceManagerNotCreatingResourceSet(String baseName, String mainAssemblyName, String cultureName)
+ public void ResourceManagerNotCreatingResourceSet(string baseName, string mainAssemblyName, string cultureName)
{
if (IsEnabled())
WriteEvent(15, baseName, mainAssemblyName, cultureName);
}
[Event(16, Level = EventLevel.Warning, Keywords = Keywords.Loader)]
- public void ResourceManagerLookupFailed(String baseName, String mainAssemblyName, String cultureName)
+ public void ResourceManagerLookupFailed(string baseName, string mainAssemblyName, string cultureName)
{
if (IsEnabled())
WriteEvent(16, baseName, mainAssemblyName, cultureName);
}
[Event(17, Level = EventLevel.Informational, Keywords = Keywords.Loader)]
- public void ResourceManagerReleasingResources(String baseName, String mainAssemblyName)
+ public void ResourceManagerReleasingResources(string baseName, string mainAssemblyName)
{
if (IsEnabled())
WriteEvent(17, baseName, mainAssemblyName);
}
[Event(18, Level = EventLevel.Warning, Keywords = Keywords.Loader)]
- public void ResourceManagerNeutralResourcesNotFound(String baseName, String mainAssemblyName, String resName)
+ public void ResourceManagerNeutralResourcesNotFound(string baseName, string mainAssemblyName, string resName)
{
if (IsEnabled())
WriteEvent(18, baseName, mainAssemblyName, resName);
}
[Event(19, Level = EventLevel.Informational, Keywords = Keywords.Loader)]
- public void ResourceManagerNeutralResourcesFound(String baseName, String mainAssemblyName, String resName)
+ public void ResourceManagerNeutralResourcesFound(string baseName, string mainAssemblyName, string resName)
{
if (IsEnabled())
WriteEvent(19, baseName, mainAssemblyName, resName);
}
[Event(20, Level = EventLevel.Informational, Keywords = Keywords.Loader)]
- public void ResourceManagerAddingCultureFromConfigFile(String baseName, String mainAssemblyName, String cultureName)
+ public void ResourceManagerAddingCultureFromConfigFile(string baseName, string mainAssemblyName, string cultureName)
{
if (IsEnabled())
WriteEvent(20, baseName, mainAssemblyName, cultureName);
}
[Event(21, Level = EventLevel.Informational, Keywords = Keywords.Loader)]
- public void ResourceManagerCultureNotFoundInConfigFile(String baseName, String mainAssemblyName, String cultureName)
+ public void ResourceManagerCultureNotFoundInConfigFile(string baseName, string mainAssemblyName, string cultureName)
{
if (IsEnabled())
WriteEvent(21, baseName, mainAssemblyName, cultureName);
}
[Event(22, Level = EventLevel.Informational, Keywords = Keywords.Loader)]
- public void ResourceManagerCultureFoundInConfigFile(String baseName, String mainAssemblyName, String cultureName)
+ public void ResourceManagerCultureFoundInConfigFile(string baseName, string mainAssemblyName, string cultureName)
{
if (IsEnabled())
WriteEvent(22, baseName, mainAssemblyName, cultureName);
// ResourceManager Event Wrappers
[NonEvent]
- public void ResourceManagerLookupStarted(String baseName, Assembly mainAssembly, String cultureName)
+ public void ResourceManagerLookupStarted(string baseName, Assembly mainAssembly, string cultureName)
{
if (IsEnabled())
ResourceManagerLookupStarted(baseName, GetName(mainAssembly), cultureName);
}
[NonEvent]
- public void ResourceManagerLookingForResourceSet(String baseName, Assembly mainAssembly, String cultureName)
+ public void ResourceManagerLookingForResourceSet(string baseName, Assembly mainAssembly, string cultureName)
{
if (IsEnabled())
ResourceManagerLookingForResourceSet(baseName, GetName(mainAssembly), cultureName);
}
[NonEvent]
- public void ResourceManagerFoundResourceSetInCache(String baseName, Assembly mainAssembly, String cultureName)
+ public void ResourceManagerFoundResourceSetInCache(string baseName, Assembly mainAssembly, string cultureName)
{
if (IsEnabled())
ResourceManagerFoundResourceSetInCache(baseName, GetName(mainAssembly), cultureName);
}
[NonEvent]
- public void ResourceManagerFoundResourceSetInCacheUnexpected(String baseName, Assembly mainAssembly, String cultureName)
+ public void ResourceManagerFoundResourceSetInCacheUnexpected(string baseName, Assembly mainAssembly, string cultureName)
{
if (IsEnabled())
ResourceManagerFoundResourceSetInCacheUnexpected(baseName, GetName(mainAssembly), cultureName);
}
[NonEvent]
- public void ResourceManagerStreamFound(String baseName, Assembly mainAssembly, String cultureName, Assembly loadedAssembly, String resourceFileName)
+ public void ResourceManagerStreamFound(string baseName, Assembly mainAssembly, string cultureName, Assembly loadedAssembly, string resourceFileName)
{
if (IsEnabled())
ResourceManagerStreamFound(baseName, GetName(mainAssembly), cultureName, GetName(loadedAssembly), resourceFileName);
}
[NonEvent]
- public void ResourceManagerStreamNotFound(String baseName, Assembly mainAssembly, String cultureName, Assembly loadedAssembly, String resourceFileName)
+ public void ResourceManagerStreamNotFound(string baseName, Assembly mainAssembly, string cultureName, Assembly loadedAssembly, string resourceFileName)
{
if (IsEnabled())
ResourceManagerStreamNotFound(baseName, GetName(mainAssembly), cultureName, GetName(loadedAssembly), resourceFileName);
}
[NonEvent]
- public void ResourceManagerGetSatelliteAssemblySucceeded(String baseName, Assembly mainAssembly, String cultureName, String assemblyName)
+ public void ResourceManagerGetSatelliteAssemblySucceeded(string baseName, Assembly mainAssembly, string cultureName, string assemblyName)
{
if (IsEnabled())
ResourceManagerGetSatelliteAssemblySucceeded(baseName, GetName(mainAssembly), cultureName, assemblyName);
}
[NonEvent]
- public void ResourceManagerGetSatelliteAssemblyFailed(String baseName, Assembly mainAssembly, String cultureName, String assemblyName)
+ public void ResourceManagerGetSatelliteAssemblyFailed(string baseName, Assembly mainAssembly, string cultureName, string assemblyName)
{
if (IsEnabled())
ResourceManagerGetSatelliteAssemblyFailed(baseName, GetName(mainAssembly), cultureName, assemblyName);
}
[NonEvent]
- public void ResourceManagerCaseInsensitiveResourceStreamLookupSucceeded(String baseName, Assembly mainAssembly, String assemblyName, String resourceFileName)
+ public void ResourceManagerCaseInsensitiveResourceStreamLookupSucceeded(string baseName, Assembly mainAssembly, string assemblyName, string resourceFileName)
{
if (IsEnabled())
ResourceManagerCaseInsensitiveResourceStreamLookupSucceeded(baseName, GetName(mainAssembly), assemblyName, resourceFileName);
}
[NonEvent]
- public void ResourceManagerCaseInsensitiveResourceStreamLookupFailed(String baseName, Assembly mainAssembly, String assemblyName, String resourceFileName)
+ public void ResourceManagerCaseInsensitiveResourceStreamLookupFailed(string baseName, Assembly mainAssembly, string assemblyName, string resourceFileName)
{
if (IsEnabled())
ResourceManagerCaseInsensitiveResourceStreamLookupFailed(baseName, GetName(mainAssembly), assemblyName, resourceFileName);
}
[NonEvent]
- public void ResourceManagerManifestResourceAccessDenied(String baseName, Assembly mainAssembly, String assemblyName, String canonicalName)
+ public void ResourceManagerManifestResourceAccessDenied(string baseName, Assembly mainAssembly, string assemblyName, string canonicalName)
{
if (IsEnabled())
ResourceManagerManifestResourceAccessDenied(baseName, GetName(mainAssembly), assemblyName, canonicalName);
}
[NonEvent]
- public void ResourceManagerNeutralResourcesSufficient(String baseName, Assembly mainAssembly, String cultureName)
+ public void ResourceManagerNeutralResourcesSufficient(string baseName, Assembly mainAssembly, string cultureName)
{
if (IsEnabled())
ResourceManagerNeutralResourcesSufficient(baseName, GetName(mainAssembly), cultureName);
}
[NonEvent]
- public void ResourceManagerCreatingResourceSet(String baseName, Assembly mainAssembly, String cultureName, String fileName)
+ public void ResourceManagerCreatingResourceSet(string baseName, Assembly mainAssembly, string cultureName, string fileName)
{
if (IsEnabled())
ResourceManagerCreatingResourceSet(baseName, GetName(mainAssembly), cultureName, fileName);
}
[NonEvent]
- public void ResourceManagerNotCreatingResourceSet(String baseName, Assembly mainAssembly, String cultureName)
+ public void ResourceManagerNotCreatingResourceSet(string baseName, Assembly mainAssembly, string cultureName)
{
if (IsEnabled())
ResourceManagerNotCreatingResourceSet(baseName, GetName(mainAssembly), cultureName);
}
[NonEvent]
- public void ResourceManagerLookupFailed(String baseName, Assembly mainAssembly, String cultureName)
+ public void ResourceManagerLookupFailed(string baseName, Assembly mainAssembly, string cultureName)
{
if (IsEnabled())
ResourceManagerLookupFailed(baseName, GetName(mainAssembly), cultureName);
}
[NonEvent]
- public void ResourceManagerReleasingResources(String baseName, Assembly mainAssembly)
+ public void ResourceManagerReleasingResources(string baseName, Assembly mainAssembly)
{
if (IsEnabled())
ResourceManagerReleasingResources(baseName, GetName(mainAssembly));
}
[NonEvent]
- public void ResourceManagerNeutralResourcesNotFound(String baseName, Assembly mainAssembly, String resName)
+ public void ResourceManagerNeutralResourcesNotFound(string baseName, Assembly mainAssembly, string resName)
{
if (IsEnabled())
ResourceManagerNeutralResourcesNotFound(baseName, GetName(mainAssembly), resName);
}
[NonEvent]
- public void ResourceManagerNeutralResourcesFound(String baseName, Assembly mainAssembly, String resName)
+ public void ResourceManagerNeutralResourcesFound(string baseName, Assembly mainAssembly, string resName)
{
if (IsEnabled())
ResourceManagerNeutralResourcesFound(baseName, GetName(mainAssembly), resName);
}
[NonEvent]
- public void ResourceManagerAddingCultureFromConfigFile(String baseName, Assembly mainAssembly, String cultureName)
+ public void ResourceManagerAddingCultureFromConfigFile(string baseName, Assembly mainAssembly, string cultureName)
{
if (IsEnabled())
ResourceManagerAddingCultureFromConfigFile(baseName, GetName(mainAssembly), cultureName);
}
[NonEvent]
- public void ResourceManagerCultureNotFoundInConfigFile(String baseName, Assembly mainAssembly, String cultureName)
+ public void ResourceManagerCultureNotFoundInConfigFile(string baseName, Assembly mainAssembly, string cultureName)
{
if (IsEnabled())
ResourceManagerCultureNotFoundInConfigFile(baseName, GetName(mainAssembly), cultureName);
}
[NonEvent]
- public void ResourceManagerCultureFoundInConfigFile(String baseName, Assembly mainAssembly, String cultureName)
+ public void ResourceManagerCultureFoundInConfigFile(string baseName, Assembly mainAssembly, string cultureName)
{
if (IsEnabled())
ResourceManagerCultureFoundInConfigFile(baseName, GetName(mainAssembly), cultureName);
private static string Serialize(ReadOnlyCollection<string> payloadName, ReadOnlyCollection<object> payload, string eventMessage)
{
if (payloadName == null || payload == null )
- return String.Empty;
+ return string.Empty;
if (payloadName.Count == 0 || payload.Count == 0)
- return String.Empty;
+ return string.Empty;
int eventDataCount = payloadName.Count;
internal protected override void OnEventSourceCreated(EventSource eventSource)
{
string eventSourceFilter = eventSourceNameFilter.Value;
- if (String.IsNullOrEmpty(eventSourceFilter) || (eventSource.Name.IndexOf(eventSourceFilter, StringComparison.OrdinalIgnoreCase) >= 0))
+ if (string.IsNullOrEmpty(eventSourceFilter) || (eventSource.Name.IndexOf(eventSourceFilter, StringComparison.OrdinalIgnoreCase) >= 0))
{
EnableEvents(eventSource, EventLevel.LogAlways, EventKeywords.All, null);
}
internal protected override void OnEventWritten(EventWrittenEventArgs eventData)
{
string eventFilter = eventSourceEventFilter.Value;
- if (String.IsNullOrEmpty(eventFilter) || (eventData.EventName.IndexOf(eventFilter, StringComparison.OrdinalIgnoreCase) >= 0))
+ if (string.IsNullOrEmpty(eventFilter) || (eventData.EventName.IndexOf(eventFilter, StringComparison.OrdinalIgnoreCase) >= 0))
{
LogOnEventWritten(eventData);
}
#pragma warning disable 414
// dynamicMethods is an array of System.Resolver objects, used to keep
// DynamicMethodDescs alive for the lifetime of StackFrameHelper.
- private Object dynamicMethods; // Field is not used from managed.
+ private object dynamicMethods; // Field is not used from managed.
private IntPtr[] rgMethodHandle;
private string[] rgAssemblyPath;
// Define a source document. Guid's will be provided for the
// languages, vendors, and document types that we currently know
// about.
- ISymbolDocumentWriter DefineDocument(String url,
+ ISymbolDocumentWriter DefineDocument(string url,
Guid language,
Guid languageVendor,
Guid documentType);
// variable of the same name that has multiple homes throughout a
// scope. (Note: start/end offsets must not overlap in such a
// case.)
- void DefineLocalVariable(String name,
+ void DefineLocalVariable(string name,
FieldAttributes attributes,
byte[] signature,
SymAddressKind addrKind,
// Defines a custom attribute based upon its name. Not to be
// confused with Metadata custom attributes, these attributes are
// held in the symbol store.
- void SetSymAttribute(SymbolToken parent, String name, byte[] data);
+ void SetSymAttribute(SymbolToken parent, string name, byte[] data);
// Specifies that the given, fully qualified namespace name is
// being used within the currently open lexical scope. Closing the
// current scope will also stop using the namespace, and the
// namespace will be in use in all scopes that inherit from the
// currently open scope.
- void UsingNamespace(String fullName);
+ void UsingNamespace(string fullName);
}
}
public override int GetHashCode() { return m_token; }
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj is SymbolToken)
return Equals((SymbolToken)obj);
{
#region Private Constants
private const char enumSeparatorChar = ',';
- private const String enumSeparatorString = ", ";
+ private const string enumSeparatorString = ", ";
#endregion
#region Private Static Methods
if (entry == null || (getNames && entry.Names == null))
{
ulong[] values = null;
- String[] names = null;
+ string[] names = null;
bool isFlags = enumType.IsDefined(typeof(System.FlagsAttribute), false);
GetEnumValuesAndNames(
return entry;
}
- private unsafe String InternalFormattedHexString()
+ private unsafe string InternalFormattedHexString()
{
fixed (void* pValue = &JitHelpers.GetPinningHelper(this).m_data)
{
}
}
- private static String InternalFormattedHexString(object value)
+ private static string InternalFormattedHexString(object value)
{
TypeCode typeCode = Convert.GetTypeCode(value);
// direct cast from bool to byte is not allowed
return Convert.ToByte((bool)value).ToString("X2", null);
case TypeCode.Int16:
- return ((UInt16)(Int16)value).ToString("X4", null);
+ return ((ushort)(short)value).ToString("X4", null);
case TypeCode.UInt16:
- return ((UInt16)value).ToString("X4", null);
+ return ((ushort)value).ToString("X4", null);
case TypeCode.Char:
- return ((UInt16)(Char)value).ToString("X4", null);
+ return ((ushort)(char)value).ToString("X4", null);
case TypeCode.UInt32:
- return ((UInt32)value).ToString("X8", null);
+ return ((uint)value).ToString("X8", null);
case TypeCode.Int32:
- return ((UInt32)(Int32)value).ToString("X8", null);
+ return ((uint)(int)value).ToString("X8", null);
case TypeCode.UInt64:
- return ((UInt64)value).ToString("X16", null);
+ return ((ulong)value).ToString("X16", null);
case TypeCode.Int64:
- return ((UInt64)(Int64)value).ToString("X16", null);
+ return ((ulong)(long)value).ToString("X16", null);
// All unsigned types will be directly cast
default:
throw new InvalidOperationException(SR.InvalidOperation_UnknownEnumType);
}
}
- internal static String GetEnumName(RuntimeType eT, ulong ulValue)
+ internal static string GetEnumName(RuntimeType eT, ulong ulValue)
{
Debug.Assert(eT != null);
ulong[] ulValues = Enum.InternalGetValues(eT);
return null; // return null so the caller knows to .ToString() the input
}
- private static String InternalFormat(RuntimeType eT, ulong value)
+ private static string InternalFormat(RuntimeType eT, ulong value)
{
Debug.Assert(eT != null);
}
}
- private static String InternalFlagsFormat(RuntimeType eT, ulong result)
+ private static string InternalFlagsFormat(RuntimeType eT, ulong result)
{
// These values are sorted by value. Don't change this
TypeValuesAndNames entry = GetCachedValuesAndNames(eT, true);
return InternalFlagsFormat(eT, entry, result);
}
- private static String InternalFlagsFormat(RuntimeType eT, TypeValuesAndNames entry, ulong result)
+ private static string InternalFlagsFormat(RuntimeType eT, TypeValuesAndNames entry, ulong result)
{
Debug.Assert(eT != null);
- String[] names = entry.Names;
+ string[] names = entry.Names;
ulong[] values = entry.Values;
Debug.Assert(names.Length == values.Length);
return returnString;
}
- internal static ulong ToUInt64(Object value)
+ internal static ulong ToUInt64(object value)
{
// Helper function to silently convert the value to UInt64 from the other base types for enum without throwing an exception.
// This is need since the Convert functions do overflow checks.
result = Convert.ToByte((bool)value);
break;
case TypeCode.Int16:
- result = (ulong)(Int16)value;
+ result = (ulong)(short)value;
break;
case TypeCode.UInt16:
- result = (UInt16)value;
+ result = (ushort)value;
break;
case TypeCode.Char:
- result = (UInt16)(Char)value;
+ result = (ushort)(char)value;
break;
case TypeCode.UInt32:
- result = (UInt32)value;
+ result = (uint)value;
break;
case TypeCode.Int32:
result = (ulong)(int)value;
result = (ulong)value;
break;
case TypeCode.Int64:
- result = (ulong)(Int64)value;
+ result = (ulong)(long)value;
break;
// All unsigned types will be directly cast
default:
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern int InternalCompareTo(Object o1, Object o2);
+ private static extern int InternalCompareTo(object o1, object o2);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern RuntimeType InternalGetUnderlyingType(RuntimeType enumType);
private static extern void GetEnumValuesAndNames(RuntimeTypeHandle enumType, ObjectHandleOnStack values, ObjectHandleOnStack names, bool getNames);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern Object InternalBoxEnum(RuntimeType enumType, long value);
+ private static extern object InternalBoxEnum(RuntimeType enumType, long value);
#endregion
#region Public Static Methods
}
}
- public static bool TryParse(Type enumType, String value, out Object result)
+ public static bool TryParse(Type enumType, string value, out object result)
{
return TryParse(enumType, value, false, out result);
}
- public static bool TryParse(Type enumType, String value, bool ignoreCase, out Object result)
+ public static bool TryParse(Type enumType, string value, bool ignoreCase, out object result)
{
result = null;
EnumResult parseResult = new EnumResult();
return retValue;
}
- public static bool TryParse<TEnum>(String value, out TEnum result) where TEnum : struct
+ public static bool TryParse<TEnum>(string value, out TEnum result) where TEnum : struct
{
return TryParse(value, false, out result);
}
- public static bool TryParse<TEnum>(String value, bool ignoreCase, out TEnum result) where TEnum : struct
+ public static bool TryParse<TEnum>(string value, bool ignoreCase, out TEnum result) where TEnum : struct
{
result = default;
EnumResult parseResult = new EnumResult();
return retValue;
}
- public static Object Parse(Type enumType, String value)
+ public static object Parse(Type enumType, string value)
{
return Parse(enumType, value, false);
}
- public static Object Parse(Type enumType, String value, bool ignoreCase)
+ public static object Parse(Type enumType, string value, bool ignoreCase)
{
EnumResult parseResult = new EnumResult() { canThrow = true };
if (TryParseEnum(enumType, value, ignoreCase, ref parseResult))
throw parseResult.GetEnumParseException();
}
- public static TEnum Parse<TEnum>(String value) where TEnum : struct
+ public static TEnum Parse<TEnum>(string value) where TEnum : struct
{
return Parse<TEnum>(value, false);
}
- public static TEnum Parse<TEnum>(String value, bool ignoreCase) where TEnum : struct
+ public static TEnum Parse<TEnum>(string value, bool ignoreCase) where TEnum : struct
{
EnumResult parseResult = new EnumResult() { canThrow = true };
if (TryParseEnum(typeof(TEnum), value, ignoreCase, ref parseResult))
throw parseResult.GetEnumParseException();
}
- private static bool TryParseEnum(Type enumType, String value, bool ignoreCase, ref EnumResult parseResult)
+ private static bool TryParseEnum(Type enumType, string value, bool ignoreCase, ref EnumResult parseResult)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
int firstNonWhitespaceIndex = -1;
for (int i = 0; i < value.Length; i++)
{
- if (!Char.IsWhiteSpace(value[i]))
+ if (!char.IsWhiteSpace(value[i]))
{
firstNonWhitespaceIndex = i;
break;
ulong result = 0;
char firstNonWhitespaceChar = value[firstNonWhitespaceIndex];
- if (Char.IsDigit(firstNonWhitespaceChar) || firstNonWhitespaceChar == '-' || firstNonWhitespaceChar == '+')
+ if (char.IsDigit(firstNonWhitespaceChar) || firstNonWhitespaceChar == '-' || firstNonWhitespaceChar == '+')
{
Type underlyingType = GetUnderlyingType(enumType);
- Object temp;
+ object temp;
try
{
// Find the field. Let's assume that these are always static classes
// because the class is an enum.
TypeValuesAndNames entry = GetCachedValuesAndNames(rtType, true);
- String[] enumNames = entry.Names;
+ string[] enumNames = entry.Names;
ulong[] enumValues = entry.Values;
StringComparison comparison = ignoreCase ?
// Shift the starting and ending indices to eliminate whitespace
int endIndexNoWhitespace = endIndex;
- while (valueIndex < endIndex && Char.IsWhiteSpace(value[valueIndex])) valueIndex++;
- while (endIndexNoWhitespace > valueIndex && Char.IsWhiteSpace(value[endIndexNoWhitespace - 1])) endIndexNoWhitespace--;
+ while (valueIndex < endIndex && char.IsWhiteSpace(value[valueIndex])) valueIndex++;
+ while (endIndexNoWhitespace > valueIndex && char.IsWhiteSpace(value[endIndexNoWhitespace - 1])) endIndexNoWhitespace--;
int valueSubstringLength = endIndexNoWhitespace - valueIndex;
// Try to match this substring against each enum name
return GetCachedValuesAndNames(enumType, false).Values;
}
- public static String GetName(Type enumType, Object value)
+ public static string GetName(Type enumType, object value)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
return enumType.GetEnumName(value);
}
- public static String[] GetNames(Type enumType)
+ public static string[] GetNames(Type enumType)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
return enumType.GetEnumNames();
}
- internal static String[] InternalGetNames(RuntimeType enumType)
+ internal static string[] InternalGetNames(RuntimeType enumType)
{
// Get all of the names
return GetCachedValuesAndNames(enumType, true).Names;
}
- public static Object ToObject(Type enumType, Object value)
+ public static object ToObject(Type enumType, object value)
{
if (value == null)
throw new ArgumentNullException(nameof(value));
}
}
- public static bool IsDefined(Type enumType, Object value)
+ public static bool IsDefined(Type enumType, object value)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
return enumType.IsEnumDefined(value);
}
- public static String Format(Type enumType, Object value, String format)
+ public static string Format(Type enumType, object value, string format)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
private class TypeValuesAndNames
{
// Each entry contains a list of sorted pair of enum field names and values, sorted by values
- public TypeValuesAndNames(bool isFlag, ulong[] values, String[] names)
+ public TypeValuesAndNames(bool isFlag, ulong[] values, string[] names)
{
this.IsFlag = isFlag;
this.Values = values;
public bool IsFlag;
public ulong[] Values;
- public String[] Names;
+ public string[] Names;
}
#endregion
#region Private Methods
- internal unsafe Object GetValue()
+ internal unsafe object GetValue()
{
fixed (void* pValue = &JitHelpers.GetPinningHelper(this).m_data)
{
#region Object Overrides
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public extern override bool Equals(Object obj);
+ public extern override bool Equals(object obj);
public override unsafe int GetHashCode()
{
}
}
- public override String ToString()
+ public override string ToString()
{
// Returns the value in a human readable format. For PASCAL style enums who's value maps directly the name of the field is returned.
// For PASCAL style enums who's values do not map directly the decimal value of the field is returned.
#region IFormattable
[Obsolete("The provider argument is not used. Please use ToString(String).")]
- public String ToString(String format, IFormatProvider provider)
+ public string ToString(string format, IFormatProvider provider)
{
return ToString(format);
}
#endregion
#region IComparable
- public int CompareTo(Object target)
+ public int CompareTo(object target)
{
const int retIncompatibleMethodTables = 2; // indicates that the method tables did not match
const int retInvalidEnumType = 3; // indicates that the enum was of an unknown/unsupported underlying type
#endregion
#region Public Methods
- public String ToString(String format)
+ public string ToString(string format)
{
char formatCh;
if (format == null || format.Length == 0)
}
[Obsolete("The provider argument is not used. Please use ToString().")]
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
return ToString();
}
[Intrinsic]
- public Boolean HasFlag(Enum flag)
+ public bool HasFlag(Enum flag)
{
if (flag == null)
throw new ArgumentNullException(nameof(flag));
return Convert.ToDouble(GetValue(), CultureInfo.CurrentCulture);
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
return Convert.ToDecimal(GetValue(), CultureInfo.CurrentCulture);
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Enum", "DateTime"));
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
#region ToObject
[CLSCompliant(false)]
- public static Object ToObject(Type enumType, sbyte value)
+ public static object ToObject(Type enumType, sbyte value)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
return InternalBoxEnum(rtType, value);
}
- public static Object ToObject(Type enumType, short value)
+ public static object ToObject(Type enumType, short value)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
return InternalBoxEnum(rtType, value);
}
- public static Object ToObject(Type enumType, int value)
+ public static object ToObject(Type enumType, int value)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
return InternalBoxEnum(rtType, value);
}
- public static Object ToObject(Type enumType, byte value)
+ public static object ToObject(Type enumType, byte value)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
}
[CLSCompliant(false)]
- public static Object ToObject(Type enumType, ushort value)
+ public static object ToObject(Type enumType, ushort value)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
}
[CLSCompliant(false)]
- public static Object ToObject(Type enumType, uint value)
+ public static object ToObject(Type enumType, uint value)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
return InternalBoxEnum(rtType, value);
}
- public static Object ToObject(Type enumType, long value)
+ public static object ToObject(Type enumType, long value)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
}
[CLSCompliant(false)]
- public static Object ToObject(Type enumType, ulong value)
+ public static object ToObject(Type enumType, ulong value)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
return InternalBoxEnum(rtType, unchecked((long)value));
}
- private static Object ToObject(Type enumType, char value)
+ private static object ToObject(Type enumType, char value)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
return InternalBoxEnum(rtType, value);
}
- private static Object ToObject(Type enumType, bool value)
+ private static object ToObject(Type enumType, bool value)
{
if (enumType == null)
throw new ArgumentNullException(nameof(enumType));
// if you change this method's signature then you must change the code that calls it
// in excep.cpp and probably you will have to visit mscorlib.h to add the new signature
// as well as metasig.h to create the new signature type
- internal static String GetResourceStringLocal(String key)
+ internal static string GetResourceStringLocal(string key)
{
return SR.GetResourceString(key);
}
// to assign blame for crashes. Don't mess with this, such as by making it call
// another managed helper method, unless you consult with some CLR Watson experts.
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern void FailFast(String message);
+ public static extern void FailFast(string message);
// This overload of FailFast will allow you to specify the exception object
// whose bucket details *could* be used when undergoing the failfast process.
// IP for bucketing. If the exception object is not preallocated, it will use the bucket
// details contained in the object (if any).
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern void FailFast(String message, Exception exception);
+ public static extern void FailFast(string message, Exception exception);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern void FailFast(String message, Exception exception, String errorMessage);
+ public static extern void FailFast(string message, Exception exception, string errorMessage);
#if FEATURE_WIN32_REGISTRY
// This is only used by RegistryKey on Windows.
- public static String ExpandEnvironmentVariables(String name)
+ public static string ExpandEnvironmentVariables(string name)
{
if (name == null)
throw new ArgumentNullException(nameof(name));
#endif // FEATURE_WIN32_REGISTRY
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern Int32 GetProcessorCount();
+ private static extern int GetProcessorCount();
public static int ProcessorCount
{
**Arguments: None
**Exceptions: None.
==============================================================================*/
- public static String[] GetCommandLineArgs()
+ public static string[] GetCommandLineArgs()
{
/*
* There are multiple entry points to a hosted app.
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern String[] GetCommandLineArgsNative();
+ private static extern string[] GetCommandLineArgsNative();
private static string[] s_CommandLineArgs = null;
private static void SetCommandLineArgs(string[] cmdLineArgs)
**Arguments: None.
**Exceptions: None.
==============================================================================*/
- public static String NewLine
+ public static string NewLine
{
get
{
**Arguments:
**Exceptions:
==============================================================================*/
- public static String StackTrace
+ public static string StackTrace
{
[MethodImpl(MethodImplOptions.NoInlining)] // Prevent inlining from affecting where the stacktrace starts
get
}
}
- internal static String GetStackTrace(Exception e, bool needFileInfo)
+ internal static string GetStackTrace(Exception e, bool needFileInfo)
{
// Note: Setting needFileInfo to true will start up COM and set our
// apartment state. Try to not call this when passing "true"
Init();
}
- public Exception(String message)
+ public Exception(string message)
{
Init();
_message = message;
// Note: the stack trace is not started until the exception
// is thrown
//
- public Exception(String message, Exception innerException)
+ public Exception(string message, Exception innerException)
{
Init();
_message = message;
// We use the no throw version since we could be deserializing a pre-V4
// exception object that may not have this entry. In such a case, we would
// get null.
- _watsonBuckets = (Object)info.GetValueNoThrow("WatsonBuckets", typeof(byte[])); // Do not rename (binary serialization)
+ _watsonBuckets = (object)info.GetValueNoThrow("WatsonBuckets", typeof(byte[])); // Do not rename (binary serialization)
if (_className == null || HResult == 0)
}
- public virtual String Message
+ public virtual string Message
{
get
{
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- static private extern IRuntimeMethodInfo GetMethodFromStackTrace(Object stackTrace);
+ static private extern IRuntimeMethodInfo GetMethodFromStackTrace(object stackTrace);
private MethodBase GetExceptionMethodFromStackTrace()
{
// Returns the stack trace as a string. If no stack trace is
// available, null is returned.
- public virtual String StackTrace
+ public virtual string StackTrace
{
get
{
// will add the path to the source file if the PDB is present and a demand
// for FileIOPermission(PathDiscovery) succeeds, we need to make sure we
// don't store the stack trace string in the _stackTraceString member variable.
- String tempStackTraceString = Environment.GetStackTrace(this, needFileInfo);
+ string tempStackTraceString = Environment.GetStackTrace(this, needFileInfo);
return remoteStackTraceString + tempStackTraceString;
}
// This should be in a URL/URN form, such as:
// "file:///C:/Applications/Bazzal/help.html#ErrorNum42"
// Changed to be a read-write String and not return an exception
- public virtual String HelpLink
+ public virtual string HelpLink
{
get
{
}
}
- public virtual String Source
+ public virtual string Source
{
get
{
set { _source = value; }
}
- public override String ToString()
+ public override string ToString()
{
return ToString(true, true);
}
- private String ToString(bool needFileLineInfo, bool needMessage)
+ private string ToString(bool needFileLineInfo, bool needMessage)
{
- String message = (needMessage ? Message : null);
- String s;
+ string message = (needMessage ? Message : null);
+ string s;
if (message == null || message.Length <= 0)
{
throw new ArgumentNullException(nameof(info));
}
- String tempStackTraceString = _stackTraceString;
+ string tempStackTraceString = _stackTraceString;
if (_stackTrace != null)
{
_source = Source; // Set the Source information correctly before serialization
}
- info.AddValue("ClassName", GetClassName(), typeof(String)); // Do not rename (binary serialization)
- info.AddValue("Message", _message, typeof(String)); // Do not rename (binary serialization)
+ info.AddValue("ClassName", GetClassName(), typeof(string)); // Do not rename (binary serialization)
+ info.AddValue("Message", _message, typeof(string)); // Do not rename (binary serialization)
info.AddValue("Data", _data, typeof(IDictionary)); // Do not rename (binary serialization)
info.AddValue("InnerException", _innerException, typeof(Exception)); // Do not rename (binary serialization)
- info.AddValue("HelpURL", _helpURL, typeof(String)); // Do not rename (binary serialization)
- info.AddValue("StackTraceString", tempStackTraceString, typeof(String)); // Do not rename (binary serialization)
- info.AddValue("RemoteStackTraceString", _remoteStackTraceString, typeof(String)); // Do not rename (binary serialization)
- info.AddValue("RemoteStackIndex", _remoteStackIndex, typeof(Int32)); // Do not rename (binary serialization)
- info.AddValue("ExceptionMethod", null, typeof(String)); // Do not rename (binary serialization)
+ info.AddValue("HelpURL", _helpURL, typeof(string)); // Do not rename (binary serialization)
+ info.AddValue("StackTraceString", tempStackTraceString, typeof(string)); // Do not rename (binary serialization)
+ info.AddValue("RemoteStackTraceString", _remoteStackTraceString, typeof(string)); // Do not rename (binary serialization)
+ info.AddValue("RemoteStackIndex", _remoteStackIndex, typeof(int)); // Do not rename (binary serialization)
+ info.AddValue("ExceptionMethod", null, typeof(string)); // Do not rename (binary serialization)
info.AddValue("HResult", HResult); // Do not rename (binary serialization)
- info.AddValue("Source", _source, typeof(String)); // Do not rename (binary serialization)
+ info.AddValue("Source", _source, typeof(string)); // Do not rename (binary serialization)
// Serialize the Watson bucket details as well
info.AddValue("WatsonBuckets", _watsonBuckets, typeof(byte[])); // Do not rename (binary serialization)
}
}
- private String _className; //Needed for serialization.
+ private string _className; //Needed for serialization.
private MethodBase _exceptionMethod; //Needed for serialization.
- internal String _message;
+ internal string _message;
private IDictionary _data;
private Exception _innerException;
- private String _helpURL;
- private Object _stackTrace;
+ private string _helpURL;
+ private object _stackTrace;
[OptionalField] // This isnt present in pre-V4 exception objects that would be serialized.
- private Object _watsonBuckets;
- private String _stackTraceString; //Needed for serialization.
- private String _remoteStackTraceString;
+ private object _watsonBuckets;
+ private string _stackTraceString; //Needed for serialization.
+ private string _remoteStackTraceString;
private int _remoteStackIndex;
#pragma warning disable 414 // Field is not used from managed.
// _dynamicMethods is an array of System.Resolver objects, used to keep
// DynamicMethodDescs alive for the lifetime of the exception. We do this because
// the _stackTrace field holds MethodDescs, and a DynamicMethodDesc can be destroyed
// unless a System.Resolver object roots it.
- private Object _dynamicMethods;
+ private object _dynamicMethods;
#pragma warning restore 414
// @MANAGED: HResult is used from within the EE! Rename with care - check VM directory
}
}
- private String _source; // Mainly used by VB.
+ private string _source; // Mainly used by VB.
// WARNING: Don't delete/rename _xptrs and _xcode - used by functions
// on Marshal class. Native functions are in COMUtilNative.cpp & AppDomain
private IntPtr _xptrs; // Internal EE stuff
// InternalToString is called by the runtime to get the exception text
// and create a corresponding CrossAppDomainMarshaledException
- internal virtual String InternalToString()
+ internal virtual string InternalToString()
{
// Get the current stack trace string.
return ToString(true, true);
}
// See comment on ExceptionMessageKind
- internal static String GetMessageFromNativeResources(ExceptionMessageKind kind)
+ internal static string GetMessageFromNativeResources(ExceptionMessageKind kind)
{
string retMesg = null;
GetMessageFromNativeResources(kind, JitHelpers.GetStringHandleOnStack(ref retMesg));
internal sealed class CrossAppDomainMarshaledException : SystemException
{
- public CrossAppDomainMarshaledException(String message, int errorCode)
+ public CrossAppDomainMarshaledException(string message, int errorCode)
: base(message)
{
HResult = errorCode;
// Normally, only Telesto's UEF will see these exceptions.
// This override prints out the original Exception's ToString()
// output and hides the fact that it is wrapped inside another excepton.
- internal override String InternalToString()
+ internal override string InternalToString()
{
return Message;
}
internal static extern bool IsServerGC();
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void _AddMemoryPressure(UInt64 bytesAllocated);
+ private static extern void _AddMemoryPressure(ulong bytesAllocated);
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void _RemoveMemoryPressure(UInt64 bytesAllocated);
+ private static extern void _RemoveMemoryPressure(ulong bytesAllocated);
public static void AddMemoryPressure(long bytesAllocated)
{
SR.ArgumentOutOfRange_NeedPosNum);
}
- if ((4 == IntPtr.Size) && (bytesAllocated > Int32.MaxValue))
+ if ((4 == IntPtr.Size) && (bytesAllocated > int.MaxValue))
{
throw new ArgumentOutOfRangeException("pressure",
SR.ArgumentOutOfRange_MustBeNonNegInt32);
SR.ArgumentOutOfRange_NeedPosNum);
}
- if ((4 == IntPtr.Size) && (bytesAllocated > Int32.MaxValue))
+ if ((4 == IntPtr.Size) && (bytesAllocated > int.MaxValue))
{
throw new ArgumentOutOfRangeException(nameof(bytesAllocated),
SR.ArgumentOutOfRange_MustBeNonNegInt32);
// Returns the generation that obj is currently in.
//
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern int GetGeneration(Object obj);
+ public static extern int GetGeneration(object obj);
// Forces a collection of all generations from 0 through Generation.
// If we insert a call to GC.KeepAlive(this) at the end of Problem(), then
// Foo doesn't get finalized and the stream stays open.
[MethodImplAttribute(MethodImplOptions.NoInlining)] // disable optimizations
- public static void KeepAlive(Object obj)
+ public static void KeepAlive(object obj)
{
}
// Indicates that the system should not call the Finalize() method on
// an object that would normally require this call.
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void _SuppressFinalize(Object o);
+ private static extern void _SuppressFinalize(object o);
- public static void SuppressFinalize(Object obj)
+ public static void SuppressFinalize(object obj)
{
if (obj == null)
throw new ArgumentNullException(nameof(obj));
// where calling ReRegisterForFinalize is useful is inside a finalizer that
// needs to resurrect itself or an object that it references.
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void _ReRegisterForFinalize(Object o);
+ private static extern void _ReRegisterForFinalize(object o);
- public static void ReRegisterForFinalize(Object obj)
+ public static void ReRegisterForFinalize(object obj)
{
if (obj == null)
throw new ArgumentNullException(nameof(obj));
index++;
}
- CultureInfo temp = GetCultureByName(new String(languages, 0, index), true);
+ CultureInfo temp = GetCultureByName(new string(languages, 0, index), true);
temp._isReadOnly = true;
return temp;
}
{
char c = cultureName[i];
// TODO: Names can only be RFC4646 names (ie: a-zA-Z0-9) while this allows any unicode letter/digit
- if (Char.IsLetterOrDigit(c) || c == '-' || c == '_')
+ if (char.IsLetterOrDigit(c) || c == '-' || c == '_')
{
continue;
}
//
// Equals
//
- // Implements Object.Equals(). Returns a boolean indicating whether
+ // Implements object.Equals(). Returns a boolean indicating whether
// or not object refers to the same CultureInfo as the current instance.
//
////////////////////////////////////////////////////////////////////////
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
- if (Object.ReferenceEquals(this, value))
+ if (object.ReferenceEquals(this, value))
return true;
CultureInfo that = value as CultureInfo;
//
// GetHashCode
//
- // Implements Object.GetHashCode(). Returns the hash code for the
+ // Implements object.GetHashCode(). Returns the hash code for the
// CultureInfo. The hash code is guaranteed to be the same for CultureInfo A
// and B where A.Equals(B) is true.
//
//
// ToString
//
- // Implements Object.ToString(). Returns the name of the CultureInfo,
+ // Implements object.ToString(). Returns the name of the CultureInfo,
// eg. "de-DE_phoneb", "en-US", or "fj-FJ".
//
////////////////////////////////////////////////////////////////////////
FillBuffer(16);
try
{
- return Decimal.ToDecimal(_buffer);
+ return decimal.ToDecimal(_buffer);
}
catch (ArgumentException e)
{
new ArraySegment<byte>(new byte[1], 0, 0);
- new Dictionary<Char, Object>();
- new Dictionary<Guid, Byte>();
- new Dictionary<Guid, Object>();
+ new Dictionary<char, object>();
+ new Dictionary<Guid, byte>();
+ new Dictionary<Guid, object>();
new Dictionary<Guid, Guid>(); // Added for Visual Studio 2010
- new Dictionary<Int16, IntPtr>();
- new Dictionary<Int32, Byte>();
- new Dictionary<Int32, Int32>();
- new Dictionary<Int32, Object>();
- new Dictionary<IntPtr, Boolean>();
- new Dictionary<IntPtr, Int16>();
- new Dictionary<Object, Boolean>();
- new Dictionary<Object, Char>();
- new Dictionary<Object, Guid>();
- new Dictionary<Object, Int32>();
- new Dictionary<Object, Int64>(); // Added for Visual Studio 2010
+ new Dictionary<short, IntPtr>();
+ new Dictionary<int, byte>();
+ new Dictionary<int, int>();
+ new Dictionary<int, object>();
+ new Dictionary<IntPtr, bool>();
+ new Dictionary<IntPtr, short>();
+ new Dictionary<object, bool>();
+ new Dictionary<object, char>();
+ new Dictionary<object, Guid>();
+ new Dictionary<object, int>();
+ new Dictionary<object, long>(); // Added for Visual Studio 2010
new Dictionary<uint, WeakReference>(); // NCL team needs this
- new Dictionary<Object, UInt32>();
- new Dictionary<UInt32, Object>();
- new Dictionary<Int64, Object>();
+ new Dictionary<object, uint>();
+ new Dictionary<uint, object>();
+ new Dictionary<long, object>();
// to genereate mdil for Dictionary instantiation when key is user defined value type
- new Dictionary<Guid, Int32>();
+ new Dictionary<Guid, int>();
// Microsoft.Windows.Design
- new Dictionary<System.Reflection.MemberTypes, Object>();
+ new Dictionary<System.Reflection.MemberTypes, object>();
new EnumEqualityComparer<System.Reflection.MemberTypes>();
// Microsoft.Expression.DesignModel
- new Dictionary<Object, KeyValuePair<Object, Object>>();
- new Dictionary<KeyValuePair<Object, Object>, Object>();
+ new Dictionary<object, KeyValuePair<object, object>>();
+ new Dictionary<KeyValuePair<object, object>, object>();
- NullableHelper<Boolean>();
- NullableHelper<Byte>();
- NullableHelper<Char>();
+ NullableHelper<bool>();
+ NullableHelper<byte>();
+ NullableHelper<char>();
NullableHelper<DateTime>();
- NullableHelper<Decimal>();
- NullableHelper<Double>();
+ NullableHelper<decimal>();
+ NullableHelper<double>();
NullableHelper<Guid>();
- NullableHelper<Int16>();
- NullableHelper<Int32>();
- NullableHelper<Int64>();
- NullableHelper<Single>();
+ NullableHelper<short>();
+ NullableHelper<int>();
+ NullableHelper<long>();
+ NullableHelper<float>();
NullableHelper<TimeSpan>();
NullableHelper<DateTimeOffset>(); // For SQL
- new List<Boolean>();
- new List<Byte>();
- new List<Char>();
+ new List<bool>();
+ new List<byte>();
+ new List<char>();
new List<DateTime>();
- new List<Decimal>();
- new List<Double>();
+ new List<decimal>();
+ new List<double>();
new List<Guid>();
- new List<Int16>();
- new List<Int32>();
- new List<Int64>();
+ new List<short>();
+ new List<int>();
+ new List<long>();
new List<TimeSpan>();
- new List<SByte>();
- new List<Single>();
- new List<UInt16>();
- new List<UInt32>();
- new List<UInt64>();
+ new List<sbyte>();
+ new List<float>();
+ new List<ushort>();
+ new List<uint>();
+ new List<ulong>();
new List<IntPtr>();
- new List<KeyValuePair<Object, Object>>();
+ new List<KeyValuePair<object, object>>();
new List<GCHandle>(); // NCL team needs this
new List<DateTimeOffset>();
- new KeyValuePair<Char, UInt16>('\0', UInt16.MinValue);
- new KeyValuePair<UInt16, Double>(UInt16.MinValue, Double.MinValue);
- new KeyValuePair<Object, Int32>(string.Empty, Int32.MinValue);
- new KeyValuePair<Int32, Int32>(Int32.MinValue, Int32.MinValue);
- SZArrayHelper<Boolean>(null);
- SZArrayHelper<Byte>(null);
+ new KeyValuePair<char, ushort>('\0', ushort.MinValue);
+ new KeyValuePair<ushort, double>(ushort.MinValue, double.MinValue);
+ new KeyValuePair<object, int>(string.Empty, int.MinValue);
+ new KeyValuePair<int, int>(int.MinValue, int.MinValue);
+ SZArrayHelper<bool>(null);
+ SZArrayHelper<byte>(null);
SZArrayHelper<DateTime>(null);
- SZArrayHelper<Decimal>(null);
- SZArrayHelper<Double>(null);
+ SZArrayHelper<decimal>(null);
+ SZArrayHelper<double>(null);
SZArrayHelper<Guid>(null);
- SZArrayHelper<Int16>(null);
- SZArrayHelper<Int32>(null);
- SZArrayHelper<Int64>(null);
+ SZArrayHelper<short>(null);
+ SZArrayHelper<int>(null);
+ SZArrayHelper<long>(null);
SZArrayHelper<TimeSpan>(null);
- SZArrayHelper<SByte>(null);
- SZArrayHelper<Single>(null);
- SZArrayHelper<UInt16>(null);
- SZArrayHelper<UInt32>(null);
- SZArrayHelper<UInt64>(null);
+ SZArrayHelper<sbyte>(null);
+ SZArrayHelper<float>(null);
+ SZArrayHelper<ushort>(null);
+ SZArrayHelper<uint>(null);
+ SZArrayHelper<ulong>(null);
SZArrayHelper<DateTimeOffset>(null);
SZArrayHelper<CustomAttributeTypedArgument>(null);
}
// System.Runtime.CompilerServices.AsyncTaskMethodBuilder`1[System.__Canon]
// System.Runtime.CompilerServices.TaskAwaiter'[System.__Canon]
- private static async Task<String> AsyncHelper2<T>()
+ private static async Task<string> AsyncHelper2<T>()
{
return await Task.FromResult<string>("");
}
// 1. Multicast delegate
// 2. Secure/Wrapper delegate
// 3. Inner delegate of secure delegate where the secure delegate security context is a collectible method
- private Object _invocationList;
+ private object _invocationList;
private IntPtr _invocationCount;
// This constructor is called from the class generated by the
// compiler generated code (This must match the constructor
// in Delegate
- protected MulticastDelegate(Object target, String method) : base(target, method)
+ protected MulticastDelegate(object target, string method) : base(target, method)
{
}
// This constructor is called from a class to generate a
// delegate based upon a static method name and the Type object
// for the class defining the method.
- protected MulticastDelegate(Type target, String method) : base(target, method)
+ protected MulticastDelegate(Type target, string method) : base(target, method)
{
}
// equals returns true IIF the delegate is not null and has the
// same target, method and invocation list as this object
- public override sealed bool Equals(Object obj)
+ public override sealed bool Equals(object obj)
{
if (obj == null)
return false;
}
else
{
- Debug.Assert((_invocationList as Object[]) != null, "empty invocation list on multicast delegate");
+ Debug.Assert((_invocationList as object[]) != null, "empty invocation list on multicast delegate");
return InvocationListEquals(d);
}
}
// Recursive function which will check for equality of the invocation list.
private bool InvocationListEquals(MulticastDelegate d)
{
- Debug.Assert(d != null && (_invocationList as Object[]) != null, "bogus delegate in multicast list comparison");
- Object[] invocationList = _invocationList as Object[];
+ Debug.Assert(d != null && (_invocationList as object[]) != null, "bogus delegate in multicast list comparison");
+ object[] invocationList = _invocationList as object[];
if (d._invocationCount != _invocationCount)
return false;
for (int i = 0; i < invocationCount; i++)
{
Delegate dd = (Delegate)invocationList[i];
- Object[] dInvocationList = d._invocationList as Object[];
+ object[] dInvocationList = d._invocationList as object[];
if (!dd.Equals(dInvocationList[i]))
return false;
}
return true;
}
- private bool TrySetSlot(Object[] a, int index, Object o)
+ private bool TrySetSlot(object[] a, int index, object o)
{
- if (a[index] == null && System.Threading.Interlocked.CompareExchange<Object>(ref a[index], o, null) == null)
+ if (a[index] == null && System.Threading.Interlocked.CompareExchange<object>(ref a[index], o, null) == null)
return true;
// The slot may be already set because we have added and removed the same method before.
return false;
}
- private MulticastDelegate NewMulticastDelegate(Object[] invocationList, int invocationCount, bool thisIsMultiCastAlready)
+ private MulticastDelegate NewMulticastDelegate(object[] invocationList, int invocationCount, bool thisIsMultiCastAlready)
{
// First, allocate a new multicast delegate just like this one, i.e. same type as the this object
MulticastDelegate result = (MulticastDelegate)InternalAllocLike(this);
return result;
}
- internal MulticastDelegate NewMulticastDelegate(Object[] invocationList, int invocationCount)
+ internal MulticastDelegate NewMulticastDelegate(object[] invocationList, int invocationCount)
{
return NewMulticastDelegate(invocationList, invocationCount, false);
}
// to form a new delegate.
protected override sealed Delegate CombineImpl(Delegate follow)
{
- if ((Object)follow == null) // cast to object for a more efficient test
+ if ((object)follow == null) // cast to object for a more efficient test
return this;
// Verify that the types are the same...
throw new ArgumentException(SR.Arg_DlgtTypeMis);
MulticastDelegate dFollow = (MulticastDelegate)follow;
- Object[] resultList;
+ object[] resultList;
int followCount = 1;
- Object[] followList = dFollow._invocationList as Object[];
+ object[] followList = dFollow._invocationList as object[];
if (followList != null)
followCount = (int)dFollow._invocationCount;
int resultCount;
- Object[] invocationList = _invocationList as Object[];
+ object[] invocationList = _invocationList as object[];
if (invocationList == null)
{
resultCount = 1 + followCount;
- resultList = new Object[resultCount];
+ resultList = new object[resultCount];
resultList[0] = this;
if (followList == null)
{
while (allocCount < resultCount)
allocCount *= 2;
- resultList = new Object[allocCount];
+ resultList = new object[allocCount];
for (int i = 0; i < invocationCount; i++)
resultList[i] = invocationList[i];
}
}
- private Object[] DeleteFromInvocationList(Object[] invocationList, int invocationCount, int deleteIndex, int deleteCount)
+ private object[] DeleteFromInvocationList(object[] invocationList, int invocationCount, int deleteIndex, int deleteCount)
{
- Object[] thisInvocationList = _invocationList as Object[];
+ object[] thisInvocationList = _invocationList as object[];
int allocCount = thisInvocationList.Length;
while (allocCount / 2 >= invocationCount - deleteCount)
allocCount /= 2;
- Object[] newInvocationList = new Object[allocCount];
+ object[] newInvocationList = new object[allocCount];
for (int i = 0; i < deleteIndex; i++)
newInvocationList[i] = invocationList[i];
return newInvocationList;
}
- private bool EqualInvocationLists(Object[] a, Object[] b, int start, int count)
+ private bool EqualInvocationLists(object[] a, object[] b, int start, int count)
{
for (int i = 0; i < count; i++)
{
if (v == null)
return this;
- if (v._invocationList as Object[] == null)
+ if (v._invocationList as object[] == null)
{
- Object[] invocationList = _invocationList as Object[];
+ object[] invocationList = _invocationList as object[];
if (invocationList == null)
{
// they are both not real Multicast
}
else
{
- Object[] list = DeleteFromInvocationList(invocationList, invocationCount, i, 1);
+ object[] list = DeleteFromInvocationList(invocationList, invocationCount, i, 1);
return NewMulticastDelegate(list, invocationCount - 1, true);
}
}
}
else
{
- Object[] invocationList = _invocationList as Object[];
+ object[] invocationList = _invocationList as object[];
if (invocationList != null)
{
int invocationCount = (int)_invocationCount;
int vInvocationCount = (int)v._invocationCount;
for (int i = invocationCount - vInvocationCount; i >= 0; i--)
{
- if (EqualInvocationLists(invocationList, v._invocationList as Object[], i, vInvocationCount))
+ if (EqualInvocationLists(invocationList, v._invocationList as object[], i, vInvocationCount))
{
if (invocationCount - vInvocationCount == 0)
{
}
else
{
- Object[] list = DeleteFromInvocationList(invocationList, invocationCount, i, vInvocationCount);
+ object[] list = DeleteFromInvocationList(invocationList, invocationCount, i, vInvocationCount);
return NewMulticastDelegate(list, invocationCount - vInvocationCount, true);
}
}
public override sealed Delegate[] GetInvocationList()
{
Delegate[] del;
- Object[] invocationList = _invocationList as Object[];
+ object[] invocationList = _invocationList as object[];
if (invocationList == null)
{
del = new Delegate[1];
}
}
- Object[] invocationList = _invocationList as Object[];
+ object[] invocationList = _invocationList as object[];
if (invocationList == null)
{
return base.GetHashCode();
}
}
- internal override Object GetTarget()
+ internal override object GetTarget()
{
if (_invocationCount != (IntPtr)0)
{
}
else
{
- Object[] invocationList = _invocationList as Object[];
+ object[] invocationList = _invocationList as object[];
if (invocationList != null)
{
int invocationCount = (int)_invocationCount;
if (_invocationCount != (IntPtr)0 && _invocationList != null)
{
// multicast case
- Object[] invocationList = _invocationList as Object[];
+ object[] invocationList = _invocationList as object[];
if (invocationList != null)
{
int index = (int)_invocationCount - 1;
}
[System.Diagnostics.DebuggerNonUserCode]
- private void CtorClosed(Object target, IntPtr methodPtr)
+ private void CtorClosed(object target, IntPtr methodPtr)
{
if (target == null)
ThrowNullThisInDelegateToInstance();
}
[System.Diagnostics.DebuggerNonUserCode]
- private void CtorClosedStatic(Object target, IntPtr methodPtr)
+ private void CtorClosedStatic(object target, IntPtr methodPtr)
{
this._target = target;
this._methodPtr = methodPtr;
}
[System.Diagnostics.DebuggerNonUserCode]
- private void CtorRTClosed(Object target, IntPtr methodPtr)
+ private void CtorRTClosed(object target, IntPtr methodPtr)
{
this._target = target;
this._methodPtr = AdjustTarget(target, methodPtr);
}
[System.Diagnostics.DebuggerNonUserCode]
- private void CtorOpened(Object target, IntPtr methodPtr, IntPtr shuffleThunk)
+ private void CtorOpened(object target, IntPtr methodPtr, IntPtr shuffleThunk)
{
this._target = this;
this._methodPtr = shuffleThunk;
}
[System.Diagnostics.DebuggerNonUserCode]
- private void CtorVirtualDispatch(Object target, IntPtr methodPtr, IntPtr shuffleThunk)
+ private void CtorVirtualDispatch(object target, IntPtr methodPtr, IntPtr shuffleThunk)
{
this._target = this;
this._methodPtr = shuffleThunk;
}
[System.Diagnostics.DebuggerNonUserCode]
- private void CtorCollectibleClosedStatic(Object target, IntPtr methodPtr, IntPtr gchandle)
+ private void CtorCollectibleClosedStatic(object target, IntPtr methodPtr, IntPtr gchandle)
{
this._target = target;
this._methodPtr = methodPtr;
}
[System.Diagnostics.DebuggerNonUserCode]
- private void CtorCollectibleOpened(Object target, IntPtr methodPtr, IntPtr shuffleThunk, IntPtr gchandle)
+ private void CtorCollectibleOpened(object target, IntPtr methodPtr, IntPtr shuffleThunk, IntPtr gchandle)
{
this._target = this;
this._methodPtr = shuffleThunk;
}
[System.Diagnostics.DebuggerNonUserCode]
- private void CtorCollectibleVirtualDispatch(Object target, IntPtr methodPtr, IntPtr shuffleThunk, IntPtr gchandle)
+ private void CtorCollectibleVirtualDispatch(object target, IntPtr methodPtr, IntPtr shuffleThunk, IntPtr gchandle)
{
this._target = this;
this._methodPtr = shuffleThunk;
internal static class HashHelpers
{
- public static readonly int RandomSeed = new Random().Next(Int32.MinValue, Int32.MaxValue);
+ public static readonly int RandomSeed = new Random().Next(int.MinValue, int.MaxValue);
public static int Combine(int h1, int h2)
{
// replace Equals with EqualsValue for value types).
//
- public virtual bool Equals(Object obj)
+ public virtual bool Equals(object obj)
{
return RuntimeHelpers.Equals(this, obj);
}
- public static bool Equals(Object objA, Object objB)
+ public static bool Equals(object objA, object objB)
{
if (objA == objB)
{
}
[System.Runtime.Versioning.NonVersionable]
- public static bool ReferenceEquals(Object objA, Object objB)
+ public static bool ReferenceEquals(object objA, object objB)
{
return objA == objB;
}
// support the ICloneable interface.
//
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- protected extern Object MemberwiseClone();
+ protected extern object MemberwiseClone();
// Sets the value specified in the variant on the field
//
- private void FieldSetter(string typeName, string fieldName, Object val)
+ private void FieldSetter(string typeName, string fieldName, object val)
{
Debug.Assert(typeName != null);
Debug.Assert(fieldName != null);
// Gets the value specified in the variant on the field
//
- private void FieldGetter(string typeName, string fieldName, ref Object val)
+ private void FieldGetter(string typeName, string fieldName, ref object val)
{
Debug.Assert(typeName != null);
Debug.Assert(fieldName != null);
{
// ChangeType
// This binder uses OLEAUT to change the type of the variant.
- public override Object ChangeType(Object value, Type type, CultureInfo cultureInfo)
+ public override object ChangeType(object value, Type type, CultureInfo cultureInfo)
{
Variant myValue = new Variant(value);
if (cultureInfo == null)
#endif
// Specify the LocalBool flag to have BOOL values converted to local language rather
// than 0 or -1.
- Object RetObj = OAVariantLib.ChangeType(myValue, type, OAVariantLib.LocalBool, cultureInfo).ToObject();
+ object RetObj = OAVariantLib.ChangeType(myValue, type, OAVariantLib.LocalBool, cultureInfo).ToObject();
#if DISPLAY_DEBUG_INFO
Console.WriteLine("Object returned from ChangeType is of type: " + RetObj.GetType().Name);
return resolvedAssembly;
}
- public static Assembly LoadFrom(String assemblyFile)
+ public static Assembly LoadFrom(string assemblyFile)
{
if (assemblyFile == null)
throw new ArgumentNullException(nameof(assemblyFile));
return AssemblyLoadContext.Default.LoadFromAssemblyPath(fullPath);
}
- public static Assembly LoadFrom(String assemblyFile,
+ public static Assembly LoadFrom(string assemblyFile,
byte[] hashValue,
AssemblyHashAlgorithm hashAlgorithm)
{
// Locate an assembly by the long form of the assembly name.
// eg. "Toolbox.dll, version=1.1.10.1220, locale=en, publickey=1234567890123456789012345678901234567890"
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
- public static Assembly Load(String assemblyString)
+ public static Assembly Load(string assemblyString)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeAssembly.InternalLoad(assemblyString, ref stackMark);
private static Dictionary<string, Assembly> s_loadfile = new Dictionary<string, Assembly>();
- public static Assembly LoadFile(String path)
+ public static Assembly LoadFile(string path)
{
AppDomain.CheckLoadFileSupported();
return IsCustomAttributeDefined(module, module.MetadataToken, caType);
}
- internal static Object[] GetCustomAttributes(RuntimeType type, RuntimeType caType, bool inherit)
+ internal static object[] GetCustomAttributes(RuntimeType type, RuntimeType caType, bool inherit)
{
Debug.Assert(type != null);
Debug.Assert(caType != null);
if (type.GetElementType() != null)
- return (caType.IsValueType) ? Array.Empty<Object>() : CreateAttributeArrayHelper(caType, 0);
+ return (caType.IsValueType) ? Array.Empty<object>() : CreateAttributeArrayHelper(caType, 0);
if (type.IsGenericType && !type.IsGenericTypeDefinition)
type = type.GetGenericTypeDefinition() as RuntimeType;
return typedResult;
}
- internal static Object[] GetCustomAttributes(RuntimeMethodInfo method, RuntimeType caType, bool inherit)
+ internal static object[] GetCustomAttributes(RuntimeMethodInfo method, RuntimeType caType, bool inherit)
{
Debug.Assert(method != null);
Debug.Assert(caType != null);
return typedResult;
}
- internal static Object[] GetCustomAttributes(RuntimeConstructorInfo ctor, RuntimeType caType)
+ internal static object[] GetCustomAttributes(RuntimeConstructorInfo ctor, RuntimeType caType)
{
Debug.Assert(ctor != null);
Debug.Assert(caType != null);
return attributes;
}
- internal static Object[] GetCustomAttributes(RuntimePropertyInfo property, RuntimeType caType)
+ internal static object[] GetCustomAttributes(RuntimePropertyInfo property, RuntimeType caType)
{
Debug.Assert(property != null);
Debug.Assert(caType != null);
return attributes;
}
- internal static Object[] GetCustomAttributes(RuntimeEventInfo e, RuntimeType caType)
+ internal static object[] GetCustomAttributes(RuntimeEventInfo e, RuntimeType caType)
{
Debug.Assert(e != null);
Debug.Assert(caType != null);
return attributes;
}
- internal static Object[] GetCustomAttributes(RuntimeFieldInfo field, RuntimeType caType)
+ internal static object[] GetCustomAttributes(RuntimeFieldInfo field, RuntimeType caType)
{
Debug.Assert(field != null);
Debug.Assert(caType != null);
return attributes;
}
- internal static Object[] GetCustomAttributes(RuntimeParameterInfo parameter, RuntimeType caType)
+ internal static object[] GetCustomAttributes(RuntimeParameterInfo parameter, RuntimeType caType)
{
Debug.Assert(parameter != null);
Debug.Assert(caType != null);
return attributes;
}
- internal static Object[] GetCustomAttributes(RuntimeAssembly assembly, RuntimeType caType)
+ internal static object[] GetCustomAttributes(RuntimeAssembly assembly, RuntimeType caType)
{
Debug.Assert(assembly != null);
Debug.Assert(caType != null);
return attributes;
}
- internal static Object[] GetCustomAttributes(RuntimeModule module, RuntimeType caType)
+ internal static object[] GetCustomAttributes(RuntimeModule module, RuntimeType caType)
{
Debug.Assert(module != null);
Debug.Assert(caType != null);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern unsafe Object _CreateCaObject(RuntimeModule pModule, RuntimeType type, IRuntimeMethodInfo pCtor, byte** ppBlob, byte* pEndBlob, int* pcNamedArgs);
- private static unsafe Object CreateCaObject(RuntimeModule module, RuntimeType type, IRuntimeMethodInfo ctor, ref IntPtr blob, IntPtr blobEnd, out int namedArgs)
+ private static extern unsafe object _CreateCaObject(RuntimeModule pModule, RuntimeType type, IRuntimeMethodInfo pCtor, byte** ppBlob, byte* pEndBlob, int* pcNamedArgs);
+ private static unsafe object CreateCaObject(RuntimeModule module, RuntimeType type, IRuntimeMethodInfo ctor, ref IntPtr blob, IntPtr blobEnd, out int namedArgs)
{
byte* pBlob = (byte*)blob;
byte* pBlobEnd = (byte*)blobEnd;
// Assembly methods that are overridden by AssemblyBuilder should be overridden by InternalAssemblyBuilder too
#region Methods inherited from Assembly
- public override String[] GetManifestResourceNames()
+ public override string[] GetManifestResourceNames()
{
throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
}
- public override FileStream GetFile(String name)
+ public override FileStream GetFile(string name)
{
throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
}
throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
}
- public override Stream GetManifestResourceStream(Type type, String name)
+ public override Stream GetManifestResourceStream(Type type, string name)
{
throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
}
- public override Stream GetManifestResourceStream(String name)
+ public override Stream GetManifestResourceStream(string name)
{
throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
}
- public override ManifestResourceInfo GetManifestResourceInfo(String resourceName)
+ public override ManifestResourceInfo GetManifestResourceInfo(string resourceName)
{
throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
}
- public override String Location
+ public override string Location
{
get
{
}
}
- public override String CodeBase
+ public override string CodeBase
{
get
{
throw new NotSupportedException(SR.NotSupported_DynamicAssembly);
}
- public override String ImageRuntimeVersion
+ public override string ImageRuntimeVersion
{
get
{
**********************************************/
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
public ModuleBuilder DefineDynamicModule(
- String name)
+ string name)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return DefineDynamicModuleInternal(name, false, ref stackMark);
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
public ModuleBuilder DefineDynamicModule(
- String name,
+ string name,
bool emitSymbolInfo) // specify if emit symbol info or not
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
}
private ModuleBuilder DefineDynamicModuleInternal(
- String name,
+ string name,
bool emitSymbolInfo, // specify if emit symbol info or not
ref StackCrawlMark stackMark)
{
}
private ModuleBuilder DefineDynamicModuleInternalNoLock(
- String name,
+ string name,
bool emitSymbolInfo, // specify if emit symbol info or not
ref StackCrawlMark stackMark)
{
{
writer = SymWrapperCore.SymWriter.CreateSymWriter();
- String fileName = "Unused"; // this symfile is never written to disk so filename does not matter.
+ string fileName = "Unused"; // this symfile is never written to disk so filename does not matter.
// Pass the "real" module to the VM
pInternalSymWriter = ModuleBuilder.nCreateISymWriterForDynamicModule(dynModule.InternalModule, fileName);
#endregion
#region ICustomAttributeProvider Members
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
return InternalAssembly.GetCustomAttributes(inherit);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
return InternalAssembly.GetCustomAttributes(attributeType, inherit);
}
#region Assembly overrides
// Returns the names of all the resources
- public override String[] GetManifestResourceNames()
+ public override string[] GetManifestResourceNames()
{
return InternalAssembly.GetManifestResourceNames();
}
- public override FileStream GetFile(String name)
+ public override FileStream GetFile(string name)
{
return InternalAssembly.GetFile(name);
}
return InternalAssembly.GetFiles(getResourceModules);
}
- public override Stream GetManifestResourceStream(Type type, String name)
+ public override Stream GetManifestResourceStream(Type type, string name)
{
return InternalAssembly.GetManifestResourceStream(type, name);
}
- public override Stream GetManifestResourceStream(String name)
+ public override Stream GetManifestResourceStream(string name)
{
return InternalAssembly.GetManifestResourceStream(name);
}
- public override ManifestResourceInfo GetManifestResourceInfo(String resourceName)
+ public override ManifestResourceInfo GetManifestResourceInfo(string resourceName)
{
return InternalAssembly.GetManifestResourceInfo(resourceName);
}
- public override String Location
+ public override string Location
{
get
{
}
}
- public override String ImageRuntimeVersion
+ public override string ImageRuntimeVersion
{
get
{
}
}
- public override String CodeBase
+ public override string CodeBase
{
get
{
return InternalAssembly.GetName(copiedName);
}
- public override String FullName
+ public override string FullName
{
get
{
}
}
- public override Type GetType(String name, bool throwOnError, bool ignoreCase)
+ public override Type GetType(string name, bool throwOnError, bool ignoreCase)
{
return InternalAssembly.GetType(name, throwOnError, ignoreCase);
}
}
}
- public override Module GetModule(String name)
+ public override Module GetModule(string name)
{
return InternalAssembly.GetModule(name);
}
}
}
- public override Int64 HostContext
+ public override long HostContext
{
get
{
*
**********************************************/
public ModuleBuilder GetDynamicModule(
- String name) // the name of module for the look up
+ string name) // the name of module for the look up
{
lock (SyncRoot)
{
}
private ModuleBuilder GetDynamicModuleNoLock(
- String name) // the name of module for the look up
+ string name) // the name of module for the look up
{
if (name == null)
throw new ArgumentNullException(nameof(name));
{
internal AssemblyBuilderData(
InternalAssemblyBuilder assembly,
- String strAssemblyName,
+ string strAssemblyName,
AssemblyBuilderAccess access)
{
m_assembly = assembly;
}
// Helper to ensure the type name is unique underneath assemblyBuilder
- internal void CheckTypeNameConflict(String strTypeName, TypeBuilder enclosingType)
+ internal void CheckTypeNameConflict(string strTypeName, TypeBuilder enclosingType)
{
for (int i = 0; i < m_moduleBuilderList.Count; i++)
{
internal List<ModuleBuilder> m_moduleBuilderList;
internal List<ResWriterData> m_resWriterList;
- internal String m_strAssemblyName;
+ internal string m_strAssemblyName;
internal AssemblyBuilderAccess m_access;
private InternalAssemblyBuilder m_assembly;
internal Assembly m_ISymWrapperAssembly;
// For unmanaged resources
- internal String m_strResourceFileName;
+ internal string m_strResourceFileName;
internal byte[] m_resourceBytes;
internal NativeVersionInfo m_nativeVersion;
internal bool m_hasUnmanagedVersionInfo;
**********************************************/
internal class ResWriterData
{
- internal String m_strName;
- internal String m_strFileName;
- internal String m_strFullFileName;
+ internal string m_strName;
+ internal string m_strFileName;
+ internal string m_strFullFileName;
internal Stream m_memoryStream;
internal ResWriterData m_nextResWriter;
internal ResourceAttributes m_attribute;
m_lcid = -1;
}
- internal String m_strDescription;
- internal String m_strCompany;
- internal String m_strTitle;
- internal String m_strCopyright;
- internal String m_strTrademark;
- internal String m_strProduct;
- internal String m_strProductVersion;
- internal String m_strFileVersion;
+ internal string m_strDescription;
+ internal string m_strCompany;
+ internal string m_strTitle;
+ internal string m_strCopyright;
+ internal string m_strTrademark;
+ internal string m_strProduct;
+ internal string m_strProductVersion;
+ internal string m_strFileVersion;
internal int m_lcid;
}
}
#region Constructor
- internal ConstructorBuilder(String name, MethodAttributes attributes, CallingConventions callingConvention,
+ internal ConstructorBuilder(string name, MethodAttributes attributes, CallingConventions callingConvention,
Type[] parameterTypes, Type[][] requiredCustomModifiers, Type[][] optionalCustomModifiers, ModuleBuilder mod, TypeBuilder type)
{
int sigLength;
token = m_methodBuilder.GetToken();
}
- internal ConstructorBuilder(String name, MethodAttributes attributes, CallingConventions callingConvention,
+ internal ConstructorBuilder(string name, MethodAttributes attributes, CallingConventions callingConvention,
Type[] parameterTypes, ModuleBuilder mod, TypeBuilder type) :
this(name, attributes, callingConvention, parameterTypes, null, null, mod, type)
{
#endregion
#region Object Overrides
- public override String ToString()
+ public override string ToString()
{
return m_methodBuilder.ToString();
}
get { return m_methodBuilder.DeclaringType; }
}
- public override String Name
+ public override string Name
{
get { return m_methodBuilder.Name; }
}
#endregion
#region MethodBase Overrides
- public override Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
#endregion
#region ConstructorInfo Overrides
- public override Object Invoke(BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ public override object Invoke(BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
#endregion
#region ICustomAttributeProvider Implementation
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
return m_methodBuilder.GetCustomAttributes(inherit);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
return m_methodBuilder.GetCustomAttributes(attributeType, inherit);
}
return m_methodBuilder.GetToken();
}
- public ParameterBuilder DefineParameter(int iSequence, ParameterAttributes attributes, String strParamName)
+ public ParameterBuilder DefineParameter(int iSequence, ParameterAttributes attributes, string strParamName)
{
// Theoretically we shouldn't allow iSequence to be 0 because in reflection ctors don't have
// return parameters. But we'll allow it for backward compatibility with V2. The attributes
return m_methodBuilder.ReturnType;
}
- public String Signature
+ public string Signature
{
get { return m_methodBuilder.Signature; }
}
{
// public constructor to form the custom attribute with constructor and constructor
// parameters.
- public CustomAttributeBuilder(ConstructorInfo con, Object[] constructorArgs)
+ public CustomAttributeBuilder(ConstructorInfo con, object[] constructorArgs)
{
InitCustomAttributeBuilder(con, constructorArgs,
- new PropertyInfo[] { }, new Object[] { },
- new FieldInfo[] { }, new Object[] { });
+ new PropertyInfo[] { }, new object[] { },
+ new FieldInfo[] { }, new object[] { });
}
// public constructor to form the custom attribute with constructor, constructor
// parameters and named properties.
- public CustomAttributeBuilder(ConstructorInfo con, Object[] constructorArgs,
- PropertyInfo[] namedProperties, Object[] propertyValues)
+ public CustomAttributeBuilder(ConstructorInfo con, object[] constructorArgs,
+ PropertyInfo[] namedProperties, object[] propertyValues)
{
InitCustomAttributeBuilder(con, constructorArgs, namedProperties,
- propertyValues, new FieldInfo[] { }, new Object[] { });
+ propertyValues, new FieldInfo[] { }, new object[] { });
}
// public constructor to form the custom attribute with constructor and constructor
// parameters.
- public CustomAttributeBuilder(ConstructorInfo con, Object[] constructorArgs,
- FieldInfo[] namedFields, Object[] fieldValues)
+ public CustomAttributeBuilder(ConstructorInfo con, object[] constructorArgs,
+ FieldInfo[] namedFields, object[] fieldValues)
{
InitCustomAttributeBuilder(con, constructorArgs, new PropertyInfo[] { },
- new Object[] { }, namedFields, fieldValues);
+ new object[] { }, namedFields, fieldValues);
}
// public constructor to form the custom attribute with constructor and constructor
// parameters.
- public CustomAttributeBuilder(ConstructorInfo con, Object[] constructorArgs,
- PropertyInfo[] namedProperties, Object[] propertyValues,
- FieldInfo[] namedFields, Object[] fieldValues)
+ public CustomAttributeBuilder(ConstructorInfo con, object[] constructorArgs,
+ PropertyInfo[] namedProperties, object[] propertyValues,
+ FieldInfo[] namedFields, object[] fieldValues)
{
InitCustomAttributeBuilder(con, constructorArgs, namedProperties,
propertyValues, namedFields, fieldValues);
{
return t != typeof(IntPtr) && t != typeof(UIntPtr);
}
- if (t == typeof(String) || t == typeof(Type))
+ if (t == typeof(string) || t == typeof(Type))
{
return true;
}
return false;
return ValidateType(t.GetElementType());
}
- return t == typeof(Object);
+ return t == typeof(object);
}
- internal void InitCustomAttributeBuilder(ConstructorInfo con, Object[] constructorArgs,
- PropertyInfo[] namedProperties, Object[] propertyValues,
- FieldInfo[] namedFields, Object[] fieldValues)
+ internal void InitCustomAttributeBuilder(ConstructorInfo con, object[] constructorArgs,
+ PropertyInfo[] namedProperties, object[] propertyValues,
+ FieldInfo[] namedFields, object[] fieldValues)
{
if (con == null)
throw new ArgumentNullException(nameof(con));
// Cache information used elsewhere.
m_con = con;
- m_constructorArgs = new Object[constructorArgs.Length];
+ m_constructorArgs = new object[constructorArgs.Length];
Array.Copy(constructorArgs, 0, m_constructorArgs, 0, constructorArgs.Length);
Type[] paramTypes;
writer.Write((byte)CustomAttributeEncoding.Enum);
EmitString(writer, type.AssemblyQualifiedName);
}
- else if (type == typeof(String))
+ else if (type == typeof(string))
{
writer.Write((byte)CustomAttributeEncoding.String);
}
}
}
- private void EmitString(BinaryWriter writer, String str)
+ private void EmitString(BinaryWriter writer, string str)
{
// Strings are emitted with a length prefix in a compressed format (1, 2 or 4 bytes) as used internally by metadata.
byte[] utf8Str = Encoding.UTF8.GetBytes(str);
writer.Write(utf8Str);
}
- private void EmitValue(BinaryWriter writer, Type type, Object value)
+ private void EmitValue(BinaryWriter writer, Type type, object value)
{
if (type.IsEnum)
{
break;
}
}
- else if (type == typeof(String))
+ else if (type == typeof(string))
{
if (value == null)
writer.Write((byte)0xff);
else
- EmitString(writer, (String)value);
+ EmitString(writer, (string)value);
}
else if (type == typeof(Type))
{
writer.Write((byte)0xff);
else
{
- String typeName = TypeNameBuilder.ToString((Type)value, TypeNameBuilder.Format.AssemblyQualifiedName);
+ string typeName = TypeNameBuilder.ToString((Type)value, TypeNameBuilder.Format.AssemblyQualifiedName);
if (typeName == null)
throw new ArgumentException(SR.Format(SR.Argument_InvalidTypeForCA, value.GetType()));
EmitString(writer, typeName);
// TypeBuilder), so we need to canonicalize this case back to Type. If we have a null value we follow the convention
// used by C# and emit a null typed as a string (it doesn't really matter what type we pick as long as it's a
// reference type).
- Type ot = value == null ? typeof(String) : value is Type ? typeof(Type) : value.GetType();
+ Type ot = value == null ? typeof(string) : value is Type ? typeof(Type) : value.GetType();
// value cannot be a "System.Object" object.
// If we allow this we will get into an infinite recursion
}
internal ConstructorInfo m_con;
- internal Object[] m_constructorArgs;
+ internal object[] m_constructorArgs;
internal byte[] m_blob;
}
}
methodHandle = new IntPtr();
fieldHandle = new IntPtr();
- Object handle = m_scope[token];
+ object handle = m_scope[token];
if (handle == null)
throw new InvalidProgramException();
internal class DynamicScope
{
#region Private Data Members
- internal List<Object> m_tokens;
+ internal List<object> m_tokens;
#endregion
#region Constructor
internal unsafe DynamicScope()
{
- m_tokens = new List<Object>();
+ m_tokens = new List<object>();
m_tokens.Add(null);
}
#endregion
return s_anonymouslyHostedDynamicMethodsModule;
ConstructorInfo transparencyCtor = typeof(SecurityTransparentAttribute).GetConstructor(Type.EmptyTypes);
- CustomAttributeBuilder transparencyAttribute = new CustomAttributeBuilder(transparencyCtor, Array.Empty<Object>());
+ CustomAttributeBuilder transparencyAttribute = new CustomAttributeBuilder(transparencyCtor, Array.Empty<object>());
List<CustomAttributeBuilder> assemblyAttributes = new List<CustomAttributeBuilder>();
assemblyAttributes.Add(transparencyAttribute);
return s_anonymouslyHostedDynamicMethodsModule;
}
- private unsafe void Init(String name,
+ private unsafe void Init(string name,
MethodAttributes attributes,
CallingConventions callingConvention,
Type returnType,
return d;
}
- public sealed override Delegate CreateDelegate(Type delegateType, Object target)
+ public sealed override Delegate CreateDelegate(Type delegateType, object target)
{
if (m_restrictedSkipVisibility)
{
// MethodInfo api. They mostly forward to RTDynamicMethod
//
- public override String ToString() { return m_dynMethod.ToString(); }
+ public override string ToString() { return m_dynMethod.ToString(); }
- public override String Name { get { return m_dynMethod.Name; } }
+ public override string Name { get { return m_dynMethod.Name; } }
public override Type DeclaringType { get { return m_dynMethod.DeclaringType; } }
get { return false; }
}
- public override Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
if ((CallingConvention & CallingConventions.VarArgs) == CallingConventions.VarArgs)
throw new NotSupportedException(SR.NotSupported_CallToVarArg);
// if we are here we passed all the previous checks. Time to look at the arguments
bool wrapExceptions = (invokeAttr & BindingFlags.DoNotWrapExceptions) == 0;
- Object retValue = null;
+ object retValue = null;
if (actualCount > 0)
{
- Object[] arguments = CheckArguments(parameters, binder, invokeAttr, culture, sig);
+ object[] arguments = CheckArguments(parameters, binder, invokeAttr, culture, sig);
retValue = RuntimeMethodHandle.InvokeMethod(null, arguments, sig, false, wrapExceptions);
// copy out. This should be made only if ByRef are present.
for (int index = 0; index < arguments.Length; index++)
return retValue;
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
return m_dynMethod.GetCustomAttributes(attributeType, inherit);
}
- public override Object[] GetCustomAttributes(bool inherit) { return m_dynMethod.GetCustomAttributes(inherit); }
+ public override object[] GetCustomAttributes(bool inherit) { return m_dynMethod.GetCustomAttributes(inherit); }
public override bool IsDefined(Type attributeType, bool inherit) { return m_dynMethod.IsDefined(attributeType, inherit); }
// DynamicMethod specific methods
//
- public ParameterBuilder DefineParameter(int position, ParameterAttributes attributes, String parameterName)
+ public ParameterBuilder DefineParameter(int position, ParameterAttributes attributes, string parameterName)
{
if (position < 0 || position > m_parameterTypes.Length)
throw new ArgumentOutOfRangeException(SR.ArgumentOutOfRange_ParamSequence);
{
internal DynamicMethod m_owner;
private RuntimeParameterInfo[] m_parameters;
- private String m_name;
+ private string m_name;
private MethodAttributes m_attributes;
private CallingConventions m_callingConvention;
- internal RTDynamicMethod(DynamicMethod owner, String name, MethodAttributes attributes, CallingConventions callingConvention)
+ internal RTDynamicMethod(DynamicMethod owner, string name, MethodAttributes attributes, CallingConventions callingConvention)
{
m_owner = owner;
m_name = name;
//
// MethodInfo api
//
- public override String ToString()
+ public override string ToString()
{
return ReturnType.FormatTypeName() + " " + FormatNameAndSig();
}
- public override String Name
+ public override string Name
{
get { return m_name; }
}
return MethodImplAttributes.IL | MethodImplAttributes.NoInlining;
}
- public override Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
// We want the creator of the DynamicMethod to control who has access to the
// DynamicMethod (just like we do for delegates). However, a user can get to
throw new ArgumentException(SR.Argument_MustBeRuntimeMethodInfo, "this");
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
if (attributeType == null)
throw new ArgumentNullException(nameof(attributeType));
if (attributeType.IsAssignableFrom(typeof(MethodImplAttribute)))
- return new Object[] { new MethodImplAttribute((MethodImplOptions)GetMethodImplementationFlags()) };
+ return new object[] { new MethodImplAttribute((MethodImplOptions)GetMethodImplementationFlags()) };
else
- return Array.Empty<Object>();
+ return Array.Empty<object>();
}
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
// support for MethodImplAttribute PCA
- return new Object[] { new MethodImplAttribute((MethodImplOptions)GetMethodImplementationFlags()) };
+ return new object[] { new MethodImplAttribute((MethodImplOptions)GetMethodImplementationFlags()) };
}
public override bool IsDefined(Type attributeType, bool inherit)
{
internal EmptyCAHolder() { }
- Object[] ICustomAttributeProvider.GetCustomAttributes(Type attributeType, bool inherit)
+ object[] ICustomAttributeProvider.GetCustomAttributes(Type attributeType, bool inherit)
{
- return Array.Empty<Object>();
+ return Array.Empty<object>();
}
- Object[] ICustomAttributeProvider.GetCustomAttributes(bool inherit)
+ object[] ICustomAttributeProvider.GetCustomAttributes(bool inherit)
{
- return Array.Empty<Object>();
+ return Array.Empty<object>();
}
bool ICustomAttributeProvider.IsDefined(Type attributeType, bool inherit)
// Define literal for enum
- public FieldBuilder DefineLiteral(string literalName, Object literalValue)
+ public FieldBuilder DefineLiteral(string literalName, object literalValue)
{
// Define the underlying field for the enum. It will be a non-static, private field with special name bit set.
FieldBuilder fieldBuilder = m_typeBuilder.DefineField(
}
}
- public override Object InvokeMember(
+ public override object InvokeMember(
string name,
BindingFlags invokeAttr,
Binder binder,
- Object target,
- Object[] args,
+ object target,
+ object[] args,
ParameterModifier[] modifiers,
CultureInfo culture,
string[] namedParameters)
}
//ICustomAttributeProvider
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
return m_typeBuilder.GetCustomAttributes(inherit);
}
// Return a custom attribute identified by Type
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
return m_typeBuilder.GetCustomAttributes(attributeType, inherit);
}
//
internal EventBuilder(
ModuleBuilder mod, // the module containing this EventBuilder
- String name, // Event name
+ string name, // Event name
EventAttributes attr, // event attribute such as Public, Private, and Protected defined above
//int eventType, // event type
TypeBuilder type, // containing type
}
// These are package private so that TypeBuilder can access them.
- private String m_name; // The name of the event
+ private string m_name; // The name of the event
private EventToken m_evToken; // The token of this event
private ModuleBuilder m_module;
private EventAttributes m_attributes;
return m_event;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj is EventToken)
return Equals((EventToken)obj);
private int m_fieldTok;
private FieldToken m_tkField;
private TypeBuilder m_typeBuilder;
- private String m_fieldName;
+ private string m_fieldName;
private FieldAttributes m_Attributes;
private Type m_fieldType;
#endregion
#region Constructor
- internal FieldBuilder(TypeBuilder typeBuilder, String fieldName, Type type,
+ internal FieldBuilder(TypeBuilder typeBuilder, string fieldName, Type type,
Type[] requiredCustomModifiers, Type[] optionalCustomModifiers, FieldAttributes attributes)
{
if (fieldName == null)
get { return m_typeBuilder.Module; }
}
- public override String Name
+ public override string Name
{
get { return m_fieldName; }
}
get { return m_fieldType; }
}
- public override Object GetValue(Object obj)
+ public override object GetValue(object obj)
{
// NOTE!! If this is implemented, make sure that this throws
// a NotSupportedException for Save-only dynamic assemblies.
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
- public override void SetValue(Object obj, Object val, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
+ public override void SetValue(object obj, object val, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
{
// NOTE!! If this is implemented, make sure that this throws
// a NotSupportedException for Save-only dynamic assemblies.
#endregion
#region ICustomAttributeProvider Implementation
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
TypeBuilder.SetFieldLayoutOffset(m_typeBuilder.GetModuleBuilder().GetNativeHandle(), GetToken().Token, iOffset);
}
- public void SetConstant(Object defaultValue)
+ public void SetConstant(object defaultValue)
{
m_typeBuilder.ThrowIfCreated();
public static readonly FieldToken Empty = new FieldToken();
internal int m_fieldTok;
- internal Object m_class;
+ internal object m_class;
// Creates an empty FieldToken. A publicly visible constructor so that
// it can be created on the stack.
// Returns true if obj is an instance of FieldToken and is
// equal to this instance.
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj is FieldToken)
return Equals((FieldToken)obj);
public override Guid GUID { get { throw new NotSupportedException(); } }
- public override Object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, Object target, Object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters) { throw new NotSupportedException(); }
+ public override object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters) { throw new NotSupportedException(); }
public override Assembly Assembly { get { return m_type.Assembly; } }
#endregion
#region ICustomAttributeProvider Implementation
- public override Object[] GetCustomAttributes(bool inherit) { throw new NotSupportedException(); }
+ public override object[] GetCustomAttributes(bool inherit) { throw new NotSupportedException(); }
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit) { throw new NotSupportedException(); }
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit) { throw new NotSupportedException(); }
public override bool IsDefined(Type attributeType, bool inherit) { throw new NotSupportedException(); }
#endregion
if (m_fixupData[i].m_fixupInstSize == 1)
{
//Verify that our one-byte arg will fit into a Signed Byte.
- if (updateAddr < SByte.MinValue || updateAddr > SByte.MaxValue)
+ if (updateAddr < sbyte.MinValue || updateAddr > sbyte.MaxValue)
{
throw new NotSupportedException(SR.Format(SR.NotSupported_IllegalOneByteBranch, m_fixupData[i].m_fixupPos, updateAddr));
}
PutInteger4(tempVal);
}
- public virtual void Emit(OpCode opcode, String str)
+ public virtual void Emit(OpCode opcode, string str)
{
// Puts the opcode onto the IL stream followed by the metadata token
// represented by str. The location of str is recorded for future
else
{
//Handle stloc_1, ldloc_1
- if (tempVal > Byte.MaxValue)
+ if (tempVal > byte.MaxValue)
{
throw new InvalidOperationException(SR.InvalidOperation_BadInstructionOrIndexOutOfBound);
}
return Type.GetType("System.Console, System.Console", throwOnError: true);
}
- public virtual void EmitWriteLine(String value)
+ public virtual void EmitWriteLine(string value)
{
// Emits the IL to call Console.WriteLine with a string.
Emit(OpCodes.Ldstr, value);
Type[] parameterTypes = new Type[1];
- parameterTypes[0] = typeof(String);
+ parameterTypes[0] = typeof(string);
MethodInfo mi = GetConsoleType().GetMethod("WriteLine", parameterTypes);
Emit(OpCodes.Call, mi);
}
// one of the types for which Console.WriteLine implements overloads. (e.g.
// we do *not* call ToString on the locals.
- Object cls;
+ object cls;
if (m_methodBuilder == null)
{
throw new ArgumentException(SR.InvalidOperation_BadILGeneratorUsage);
// one of the types for which Console.WriteLine implements overloads. (e.g.
// we do *not* call ToString on the fields.
- Object cls;
+ object cls;
if (fld == null)
{
return localBuilder;
}
- public virtual void UsingNamespace(String usingNamespace)
+ public virtual void UsingNamespace(string usingNamespace)
{
// Specifying the namespace to be used in evaluating locals and watches
// for the current active lexical scope.
}
internal void AddLocalSymInfoToCurrentScope(
- String strName,
+ string strName,
byte[] signature,
int slot,
int startOffset,
}
internal void AddUsingNamespaceToCurrentScope(
- String strNamespace)
+ string strNamespace)
{
int i = GetCurrentActiveScopeIndex();
if (m_localSymInfos[i] == null)
//------------------------------------------------------------------------------
// DefineDocument() wrapper
//------------------------------------------------------------------------------
- ISymbolDocumentWriter ISymbolWriter.DefineDocument(String url,
+ ISymbolDocumentWriter ISymbolWriter.DefineDocument(string url,
Guid language,
Guid languageVendor,
Guid documentType)
//------------------------------------------------------------------------------
// DefineLocalVariable() wrapper
//------------------------------------------------------------------------------
- void ISymbolWriter.DefineLocalVariable(String name,
+ void ISymbolWriter.DefineLocalVariable(string name,
FieldAttributes attributes,
byte[] signature,
SymAddressKind addrKind,
//------------------------------------------------------------------------------
// SetSymAttribute() wrapper
//------------------------------------------------------------------------------
- void ISymbolWriter.SetSymAttribute(SymbolToken parent, String name, byte[] data)
+ void ISymbolWriter.SetSymAttribute(SymbolToken parent, string name, byte[] data)
{
int hr = m_vtable.SetSymAttribute(m_pWriter, parent.GetToken(), name, data.Length, data);
if (hr < 0)
//------------------------------------------------------------------------------
// UsingNamespace() wrapper
//------------------------------------------------------------------------------
- void ISymbolWriter.UsingNamespace(String name)
+ void ISymbolWriter.UsingNamespace(string name)
{
int hr = m_vtable.UsingNamespace(m_pWriter, name);
if (hr < 0)
//------------------------------------------------------------------------------
private delegate int DInitialize(ISymUnmanagedWriter* pthis,
IntPtr emitter, //IUnknown*
- [MarshalAs(UnmanagedType.LPWStr)] String filename, //WCHAR*
+ [MarshalAs(UnmanagedType.LPWStr)] string filename, //WCHAR*
IntPtr pIStream, //IStream*
[MarshalAs(UnmanagedType.Bool)] bool fFullBuild
);
private delegate int DDefineDocument(ISymUnmanagedWriter* pthis,
- [MarshalAs(UnmanagedType.LPWStr)] String url,
+ [MarshalAs(UnmanagedType.LPWStr)] string url,
[In] ref Guid language,
[In] ref Guid languageVender,
[In] ref Guid documentType,
private delegate int DSetScopeRange(ISymUnmanagedWriter* pthis, int scopeID, int startOffset, int endOffset);
private delegate int DDefineLocalVariable(ISymUnmanagedWriter* pthis,
- [MarshalAs(UnmanagedType.LPWStr)] String name,
+ [MarshalAs(UnmanagedType.LPWStr)] string name,
int attributes,
int cSig,
[In] byte[] signature,
private delegate int DSetSymAttribute(ISymUnmanagedWriter* pthis,
int parent,
- [MarshalAs(UnmanagedType.LPWStr)] String name,
+ [MarshalAs(UnmanagedType.LPWStr)] string name,
int cData,
[In] byte[] data
);
- private delegate int DOpenNamespace(ISymUnmanagedWriter* pthis, [MarshalAs(UnmanagedType.LPWStr)] String name);
+ private delegate int DOpenNamespace(ISymUnmanagedWriter* pthis, [MarshalAs(UnmanagedType.LPWStr)] string name);
private delegate int DCloseNamespace(ISymUnmanagedWriter* pthis);
- private delegate int DUsingNamespace(ISymUnmanagedWriter* pthis, [MarshalAs(UnmanagedType.LPWStr)] String name);
+ private delegate int DUsingNamespace(ISymUnmanagedWriter* pthis, [MarshalAs(UnmanagedType.LPWStr)] string name);
#endregion
#region Public Members
- public void SetLocalSymInfo(String name)
+ public void SetLocalSymInfo(string name)
{
SetLocalSymInfo(name, 0, 0);
}
- public void SetLocalSymInfo(String name, int startOffset, int endOffset)
+ public void SetLocalSymInfo(string name, int startOffset, int endOffset)
{
ModuleBuilder dynMod;
SignatureHelper sigHelp;
{
#region Private Data Members
// Identity
- internal String m_strName; // The name of the method
+ internal string m_strName; // The name of the method
private MethodToken m_tkMethod; // The token of this method
private ModuleBuilder m_module;
internal TypeBuilder m_containingType;
#region Constructor
- internal MethodBuilder(String name, MethodAttributes attributes, CallingConventions callingConvention,
+ internal MethodBuilder(string name, MethodAttributes attributes, CallingConventions callingConvention,
Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers,
Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers,
ModuleBuilder mod, TypeBuilder type, bool bIsGlobalMethod)
mod, type, bIsGlobalMethod);
}
- private void Init(String name, MethodAttributes attributes, CallingConventions callingConvention,
+ private void Init(string name, MethodAttributes attributes, CallingConventions callingConvention,
Type returnType, Type[] returnTypeRequiredCustomModifiers, Type[] returnTypeOptionalCustomModifiers,
Type[] parameterTypes, Type[][] parameterTypeRequiredCustomModifiers, Type[][] parameterTypeOptionalCustomModifiers,
ModuleBuilder mod, TypeBuilder type, bool bIsGlobalMethod)
#endregion
#region Object Overrides
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (!(obj is MethodBuilder))
{
return this.m_strName.GetHashCode();
}
- public override String ToString()
+ public override string ToString()
{
StringBuilder sb = new StringBuilder(1000);
sb.Append("Name: " + m_strName + " " + Environment.NewLine);
#endregion
#region MemberInfo Overrides
- public override String Name
+ public override string Name
{
get
{
#endregion
#region MethodBase Overrides
- public override Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
#endregion
#region ICustomAttributeProvider Implementation
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
}
- public ParameterBuilder DefineParameter(int position, ParameterAttributes attributes, String strParamName)
+ public ParameterBuilder DefineParameter(int position, ParameterAttributes attributes, string strParamName)
{
if (position < 0)
throw new ArgumentOutOfRangeException(SR.ArgumentOutOfRange_ParamSequence);
private List<SymCustomAttr> m_symCustomAttrs;
private struct SymCustomAttr
{
- public String m_name;
+ public string m_name;
public byte[] m_data;
}
return GetModuleBuilder();
}
- public String Signature
+ public string Signature
{
get
{
// and namespace information with a given active lexical scope.
#region Internal Data Members
- internal String[] m_strName;
+ internal string[] m_strName;
internal byte[][] m_ubSignature;
internal int[] m_iLocalSlot;
internal int[] m_iStartOffset;
internal int[] m_iEndOffset;
internal int m_iLocalSymCount; // how many entries in the arrays are occupied
- internal String[] m_namespace;
+ internal string[] m_namespace;
internal int m_iNameSpaceCount;
internal const int InitialSize = 16;
#endregion
{
if (m_iNameSpaceCount == 0)
{
- m_namespace = new String[InitialSize];
+ m_namespace = new string[InitialSize];
}
else if (m_iNameSpaceCount == m_namespace.Length)
{
- String[] strTemp = new String[checked(m_iNameSpaceCount * 2)];
+ string[] strTemp = new string[checked(m_iNameSpaceCount * 2)];
Array.Copy(m_namespace, 0, strTemp, 0, m_iNameSpaceCount);
m_namespace = strTemp;
}
if (m_iLocalSymCount == 0)
{
// First time. Allocate the arrays.
- m_strName = new String[InitialSize];
+ m_strName = new string[InitialSize];
m_ubSignature = new byte[InitialSize][];
m_iLocalSlot = new int[InitialSize];
m_iStartOffset = new int[InitialSize];
Array.Copy(m_iEndOffset, 0, temp, 0, m_iLocalSymCount);
m_iEndOffset = temp;
- String[] strTemp = new String[newSize];
+ string[] strTemp = new string[newSize];
Array.Copy(m_strName, 0, strTemp, 0, m_iLocalSymCount);
m_strName = strTemp;
#endregion
#region Internal Members
- internal void AddLocalSymInfo(String strName, byte[] signature, int slot, int startOffset, int endOffset)
+ internal void AddLocalSymInfo(string strName, byte[] signature, int slot, int startOffset, int endOffset)
{
// make sure that arrays are large enough to hold addition info
EnsureCapacity();
checked { m_iLocalSymCount++; }
}
- internal void AddUsingNamespace(String strNamespace)
+ internal void AddUsingNamespace(string strNamespace)
{
EnsureCapacityNamespace();
m_namespace[m_iNameSpaceCount] = strNamespace;
return m_exceptionClass ^ m_tryStartOffset ^ m_tryEndOffset ^ m_filterOffset ^ m_handlerStartOffset ^ m_handlerEndOffset ^ (int)m_kind;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
return obj is ExceptionHandler && Equals((ExceptionHandler)obj);
}
#region MemberBase
public override MemberTypes MemberType { get { return m_method.MemberType; } }
- public override String Name { get { return m_method.Name; } }
+ public override string Name { get { return m_method.Name; } }
public override Type DeclaringType { get { return m_method.DeclaringType; } }
public override Type ReflectedType { get { return m_method.ReflectedType; } }
- public override Object[] GetCustomAttributes(bool inherit) { return m_method.GetCustomAttributes(inherit); }
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit) { return m_method.GetCustomAttributes(attributeType, inherit); }
+ public override object[] GetCustomAttributes(bool inherit) { return m_method.GetCustomAttributes(inherit); }
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit) { return m_method.GetCustomAttributes(attributeType, inherit); }
public override bool IsDefined(Type attributeType, bool inherit) { return m_method.IsDefined(attributeType, inherit); }
public override Module Module { get { return m_method.Module; } }
#endregion
public override MethodImplAttributes GetMethodImplementationFlags() { return m_method.GetMethodImplementationFlags(); }
public override RuntimeMethodHandle MethodHandle { get { throw new NotSupportedException(SR.NotSupported_DynamicModule); } }
public override MethodAttributes Attributes { get { return m_method.Attributes; } }
- public override Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
throw new NotSupportedException();
}
return m_method;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj is MethodToken)
return Equals((MethodToken)obj);
#endregion
#region ICustomAttributeProvider Members
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
return InternalModule.GetCustomAttributes(inherit);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
return InternalModule.GetCustomAttributes(attributeType, inherit);
}
public class ParameterBuilder
{
// Set the default value of the parameter
- public virtual void SetConstant(Object defaultValue)
+ public virtual void SetConstant(object defaultValue)
{
TypeBuilder.SetConstantValue(
m_methodBuilder.GetModuleBuilder(),
MethodBuilder methodBuilder,
int sequence,
ParameterAttributes attributes,
- String strParamName) // can be NULL string
+ string strParamName) // can be NULL string
{
m_iPosition = sequence;
m_strParamName = strParamName;
return m_pdToken;
}
- public virtual String Name
+ public virtual string Name
{
get { return m_strParamName; }
}
get { return ((m_attributes & ParameterAttributes.Optional) != 0); }
}
- private String m_strParamName;
+ private string m_strParamName;
private int m_iPosition;
private ParameterAttributes m_attributes;
private MethodBuilder m_methodBuilder;
return m_tkParameter;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj is ParameterToken)
return Equals((ParameterToken)obj);
//
internal PropertyBuilder(
ModuleBuilder mod, // the module containing this PropertyBuilder
- String name, // property name
+ string name, // property name
SignatureHelper sig, // property signature descriptor info
PropertyAttributes attr, // property attribute such as DefaultProperty, Bindable, DisplayBind, etc
Type returnType, // return type of the property.
//************************************************
// Set the default value of the Property
//************************************************
- public void SetConstant(Object defaultValue)
+ public void SetConstant(object defaultValue)
{
m_containingType.ThrowIfCreated();
}
// Not supported functions in dynamic module.
- public override Object GetValue(Object obj, Object[] index)
+ public override object GetValue(object obj, object[] index)
{
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
- public override Object GetValue(Object obj, BindingFlags invokeAttr, Binder binder, Object[] index, CultureInfo culture)
+ public override object GetValue(object obj, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
{
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
- public override void SetValue(Object obj, Object value, Object[] index)
+ public override void SetValue(object obj, object value, object[] index)
{
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
- public override void SetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, Object[] index, CultureInfo culture)
+ public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
{
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
get { if (m_setMethod != null) return true; else return false; }
}
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
throw new NotSupportedException(SR.NotSupported_DynamicModule);
}
- public override String Name
+ public override string Name
{
get { return m_name; }
}
}
// These are package private so that TypeBuilder can access them.
- private String m_name; // The name of the property
+ private string m_name; // The name of the property
private PropertyToken m_prToken; // The token of this property
private int m_tkProperty;
private ModuleBuilder m_moduleBuilder;
}
// Satisfy value class requirements
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj is PropertyToken)
return Equals((PropertyToken)obj);
AddElementType(CorElementType.Sentinel);
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (!(obj is SignatureHelper))
{
return m_signature;
}
- public override String ToString()
+ public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append("Length: " + m_currSig + Environment.NewLine);
return m_signature;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj is SignatureToken)
return Equals((SignatureToken)obj);
return m_string;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj is StringToken)
return Equals((StringToken)obj);
#region Private Data Members
private ModuleBuilder m_module;
private Type m_containingType;
- private String m_name;
+ private string m_name;
private CallingConventions m_callingConvention;
private Type m_returnType;
private MethodToken m_mdMethod;
#endregion
#region Constructor
- internal SymbolMethod(ModuleBuilder mod, MethodToken token, Type arrayClass, String methodName,
+ internal SymbolMethod(ModuleBuilder mod, MethodToken token, Type arrayClass, string methodName,
CallingConventions callingConvention, Type returnType, Type[] parameterTypes)
{
// This is a kind of MethodInfo to represent methods for array type of unbaked type
get { return m_containingType as Type; }
}
- public override String Name
+ public override string Name
{
get { return m_name; }
}
get { return null; }
}
- public override Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
throw new NotSupportedException(SR.NotSupported_SymbolMethod);
}
#endregion
#region ICustomAttributeProvider Implementation
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
throw new NotSupportedException(SR.NotSupported_SymbolMethod);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
throw new NotSupportedException(SR.NotSupported_SymbolMethod);
}
get { throw new NotSupportedException(SR.NotSupported_NonReflectedType); }
}
- public override Object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, Object target,
- Object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
+ public override object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target,
+ object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
{
throw new NotSupportedException(SR.NotSupported_NonReflectedType);
}
get { return this; }
}
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
throw new NotSupportedException(SR.NotSupported_NonReflectedType);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
throw new NotSupportedException(SR.NotSupported_NonReflectedType);
}
}
// If the type builder view is eqaul then it is equal
- if (tb1 != null && tb2 != null && Object.ReferenceEquals(tb1, tb2))
+ if (tb1 != null && tb2 != null && object.ReferenceEquals(tb1, tb2))
return true;
// if the runtimetype view is eqaul than it is equal
return false;
}
- internal static unsafe void SetConstantValue(ModuleBuilder module, int tk, Type destType, Object value)
+ internal static unsafe void SetConstantValue(ModuleBuilder module, int tk, Type destType, object value)
{
// This is a helper function that is used by ParameterBuilder, PropertyBuilder,
// and FieldBuilder to validate a default value and save it in the meta-data.
}
}
- public override Object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, Object target,
- Object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
+ public override object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target,
+ object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters)
{
if (!IsCreated())
throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
#endregion
#region ICustomAttributeProvider Implementation
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
if (!IsCreated())
throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
return CustomAttribute.GetCustomAttributes(m_bakedRuntimeType, typeof(object) as RuntimeType, inherit);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
if (!IsCreated())
throw new NotSupportedException(SR.NotSupported_TypeNotYetCreated);
{
if ((m_iAttr & TypeAttributes.Interface) != TypeAttributes.Interface)
{
- m_typeParent = typeof(Object);
+ m_typeParent = typeof(object);
}
else
{
return SymbolType.FormCompoundType(s, this, 0);
}
public override Guid GUID { get { throw new NotSupportedException(); } }
- public override Object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, Object target, Object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters) { throw new NotSupportedException(); }
+ public override object InvokeMember(string name, BindingFlags invokeAttr, Binder binder, object target, object[] args, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParameters) { throw new NotSupportedException(); }
public override Assembly Assembly { get { return m_type.Assembly; } }
public override RuntimeTypeHandle TypeHandle { get { throw new NotSupportedException(); } }
public override string FullName
#endregion
#region ICustomAttributeProvider Implementation
- public override Object[] GetCustomAttributes(bool inherit) { throw new NotSupportedException(); }
+ public override object[] GetCustomAttributes(bool inherit) { throw new NotSupportedException(); }
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit) { throw new NotSupportedException(); }
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit) { throw new NotSupportedException(); }
public override bool IsDefined(Type attributeType, bool inherit) { throw new NotSupportedException(); }
#endregion
return m_class;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj is TypeToken)
return Equals((TypeToken)obj);
#region MemberInfo Overrides
public override MemberTypes MemberType { get { return m_method.MemberType; } }
- public override String Name { get { return m_method.Name; } }
+ public override string Name { get { return m_method.Name; } }
public override Type DeclaringType { get { return m_type; } }
public override Type ReflectedType { get { return m_type; } }
- public override Object[] GetCustomAttributes(bool inherit) { return m_method.GetCustomAttributes(inherit); }
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit) { return m_method.GetCustomAttributes(attributeType, inherit); }
+ public override object[] GetCustomAttributes(bool inherit) { return m_method.GetCustomAttributes(inherit); }
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit) { return m_method.GetCustomAttributes(attributeType, inherit); }
public override bool IsDefined(Type attributeType, bool inherit) { return m_method.IsDefined(attributeType, inherit); }
public override Module Module { get { return m_method.Module; } }
#endregion
public override MethodImplAttributes GetMethodImplementationFlags() { return m_method.GetMethodImplementationFlags(); }
public override RuntimeMethodHandle MethodHandle { get { return m_method.MethodHandle; } }
public override MethodAttributes Attributes { get { return m_method.Attributes; } }
- public override Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
throw new NotSupportedException();
}
#region MemberInfo Overrides
public override MemberTypes MemberType { get { return m_ctor.MemberType; } }
- public override String Name { get { return m_ctor.Name; } }
+ public override string Name { get { return m_ctor.Name; } }
public override Type DeclaringType { get { return m_type; } }
public override Type ReflectedType { get { return m_type; } }
- public override Object[] GetCustomAttributes(bool inherit) { return m_ctor.GetCustomAttributes(inherit); }
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit) { return m_ctor.GetCustomAttributes(attributeType, inherit); }
+ public override object[] GetCustomAttributes(bool inherit) { return m_ctor.GetCustomAttributes(inherit); }
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit) { return m_ctor.GetCustomAttributes(attributeType, inherit); }
public override bool IsDefined(Type attributeType, bool inherit) { return m_ctor.IsDefined(attributeType, inherit); }
internal int MetadataTokenInternal
{
public override MethodImplAttributes GetMethodImplementationFlags() { return m_ctor.GetMethodImplementationFlags(); }
public override RuntimeMethodHandle MethodHandle { get { return m_ctor.MethodHandle; } }
public override MethodAttributes Attributes { get { return m_ctor.Attributes; } }
- public override Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
throw new NotSupportedException();
}
#endregion
#region ConstructorInfo Members
- public override Object Invoke(BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ public override object Invoke(BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
throw new InvalidOperationException();
}
#region MemberInfo Overrides
public override MemberTypes MemberType { get { return System.Reflection.MemberTypes.Field; } }
- public override String Name { get { return m_field.Name; } }
+ public override string Name { get { return m_field.Name; } }
public override Type DeclaringType { get { return m_type; } }
public override Type ReflectedType { get { return m_type; } }
- public override Object[] GetCustomAttributes(bool inherit) { return m_field.GetCustomAttributes(inherit); }
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit) { return m_field.GetCustomAttributes(attributeType, inherit); }
+ public override object[] GetCustomAttributes(bool inherit) { return m_field.GetCustomAttributes(inherit); }
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit) { return m_field.GetCustomAttributes(attributeType, inherit); }
public override bool IsDefined(Type attributeType, bool inherit) { return m_field.IsDefined(attributeType, inherit); }
internal int MetadataTokenInternal
{
#region Public Abstract\Virtual Members
public override Type[] GetRequiredCustomModifiers() { return m_field.GetRequiredCustomModifiers(); }
public override Type[] GetOptionalCustomModifiers() { return m_field.GetOptionalCustomModifiers(); }
- public override void SetValueDirect(TypedReference obj, Object value)
+ public override void SetValueDirect(TypedReference obj, object value)
{
throw new NotImplementedException();
}
- public override Object GetValueDirect(TypedReference obj)
+ public override object GetValueDirect(TypedReference obj)
{
throw new NotImplementedException();
}
get { throw new NotImplementedException(); }
}
public override Type FieldType { get { throw new NotImplementedException(); } }
- public override Object GetValue(Object obj) { throw new InvalidOperationException(); }
- public override void SetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture) { throw new InvalidOperationException(); }
+ public override object GetValue(object obj) { throw new InvalidOperationException(); }
+ public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture) { throw new InvalidOperationException(); }
public override FieldAttributes Attributes { get { return m_field.Attributes; } }
#endregion
}
{
internal static class MdConstant
{
- public static unsafe Object GetValue(MetadataImport scope, int token, RuntimeTypeHandle fieldTypeHandle, bool raw)
+ public static unsafe object GetValue(MetadataImport scope, int token, RuntimeTypeHandle fieldTypeHandle, bool raw)
{
CorElementType corElementType = 0;
long buffer = 0;
#endregion
#region MemberInfo Overrides
- public override String Name
+ public override string Name
{
get
{
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public override Object GetValueDirect(TypedReference obj)
+ public override object GetValueDirect(TypedReference obj)
{
return GetValue(null);
}
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public override void SetValueDirect(TypedReference obj, Object value)
+ public override void SetValueDirect(TypedReference obj, object value)
{
throw new FieldAccessException(SR.Acc_ReadOnly);
}
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public unsafe override Object GetValue(Object obj)
+ public unsafe override object GetValue(object obj)
{
return GetValue(false);
}
- public unsafe override Object GetRawConstantValue() { return GetValue(true); }
+ public unsafe override object GetRawConstantValue() { return GetValue(true); }
- private unsafe Object GetValue(bool raw)
+ private unsafe object GetValue(bool raw)
{
// Cannot cache these because they could be user defined non-agile enumerations
- Object value = MdConstant.GetValue(GetRuntimeModule().MetadataImport, m_tkField, FieldType.GetTypeHandleInternal(), raw);
+ object value = MdConstant.GetValue(GetRuntimeModule().MetadataImport, m_tkField, FieldType.GetTypeHandleInternal(), raw);
if (value == DBNull.Value)
throw new NotSupportedException(SR.Arg_EnumLitValueNotFound);
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public override void SetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
+ public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
{
throw new FieldAccessException(SR.Acc_ReadOnly);
}
return parameterTypes;
}
- internal Object[] CheckArguments(Object[] parameters, Binder binder,
+ internal object[] CheckArguments(object[] parameters, Binder binder,
BindingFlags invokeAttr, CultureInfo culture, Signature sig)
{
// copy the arguments in a different array so we detach from any user changes
- Object[] copyOfParameters = new Object[parameters.Length];
+ object[] copyOfParameters = new object[parameters.Length];
ParameterInfo[] p = null;
for (int i = 0; i < parameters.Length; i++)
{
- Object arg = parameters[i];
+ object arg = parameters[i];
RuntimeType argRT = sig.Arguments[i];
if (arg == Type.Missing)
#endregion
#region Internal Members
- internal void CheckConsistency(Object target)
+ internal void CheckConsistency(object target)
{
// only test instance fields
if ((m_fieldAttributes & FieldAttributes.Static) != FieldAttributes.Static)
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- internal void InternalSetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture, ref StackCrawlMark stackMark)
+ internal void InternalSetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture, ref StackCrawlMark stackMark)
{
INVOCATION_FLAGS invocationFlags = InvocationFlags;
RuntimeType declaringType = DeclaringType as RuntimeType;
// calling this method.
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- internal void UnsafeSetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
+ internal void UnsafeSetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
{
RuntimeType declaringType = DeclaringType as RuntimeType;
RuntimeType fieldType = (RuntimeType)FieldType;
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- internal Object InternalGetValue(Object obj, ref StackCrawlMark stackMark)
+ internal object InternalGetValue(object obj, ref StackCrawlMark stackMark)
{
INVOCATION_FLAGS invocationFlags = InvocationFlags;
RuntimeType declaringType = DeclaringType as RuntimeType;
// calling this method.
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- internal Object UnsafeGetValue(Object obj)
+ internal object UnsafeGetValue(object obj)
{
RuntimeType declaringType = DeclaringType as RuntimeType;
#endregion
#region FieldInfo Overrides
- public override Object GetValue(Object obj)
+ public override object GetValue(object obj)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return InternalGetValue(obj, ref stackMark);
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public override Object GetValueDirect(TypedReference obj)
+ public override object GetValueDirect(TypedReference obj)
{
if (obj.IsNull)
throw new ArgumentException(SR.Arg_TypedReference_Null);
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public override void SetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
+ public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, CultureInfo culture)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
InternalSetValue(obj, value, invokeAttr, binder, culture, ref stackMark);
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public override void SetValueDirect(TypedReference obj, Object value)
+ public override void SetValueDirect(TypedReference obj, object value)
{
if (obj.IsNull)
throw new ArgumentException(SR.Arg_TypedReference_Null);
throw new ArgumentNullException(nameof(name));
RuntimeType type = null;
- Object keepAlive = null;
+ object keepAlive = null;
GetType(GetNativeHandle(), name, throwOnError, ignoreCase, JitHelpers.GetObjectHandleOnStack(ref type), JitHelpers.GetObjectHandleOnStack(ref keepAlive));
GC.KeepAlive(keepAlive);
}
}
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
if (attributeType == null)
throw new ArgumentNullException(nameof(attributeType));
}
}
- public override Int64 HostContext
+ public override long HostContext
{
get
{
if (pbInMemoryResource != null)
{
//Console.WriteLine("Creating an unmanaged memory stream of length "+length);
- if (length > Int64.MaxValue)
+ if (length > long.MaxValue)
throw new NotImplementedException(SR.NotImplemented_ResourcesLongerThanInt64Max);
return new UnmanagedMemoryStream(pbInMemoryResource, (long)length, (long)length, FileAccess.Read);
}
}
- private void CheckConsistency(Object target)
+ private void CheckConsistency(object target)
{
if (target == null && IsStatic)
return;
#endregion
#region ICustomAttributeProvider
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
if (attributeType == null)
throw new ArgumentNullException(nameof(attributeType));
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public override Object Invoke(
- Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ public override object Invoke(
+ object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
INVOCATION_FLAGS invocationFlags = InvocationFlags;
bool wrapExceptions = (invokeAttr & BindingFlags.DoNotWrapExceptions) == 0;
if (actualCount > 0)
{
- Object[] arguments = CheckArguments(parameters, binder, invokeAttr, culture, sig);
- Object retValue = RuntimeMethodHandle.InvokeMethod(obj, arguments, sig, false, wrapExceptions);
+ object[] arguments = CheckArguments(parameters, binder, invokeAttr, culture, sig);
+ object retValue = RuntimeMethodHandle.InvokeMethod(obj, arguments, sig, false, wrapExceptions);
// copy out. This should be made only if ByRef are present.
for (int index = 0; index < arguments.Length; index++)
parameters[index] = arguments[index];
#region ConstructorInfo Overrides
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public override Object Invoke(BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ public override object Invoke(BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
INVOCATION_FLAGS invocationFlags = InvocationFlags;
bool wrapExceptions = (invokeAttr & BindingFlags.DoNotWrapExceptions) == 0;
if (actualCount > 0)
{
- Object[] arguments = CheckArguments(parameters, binder, invokeAttr, culture, sig);
- Object retValue = RuntimeMethodHandle.InvokeMethod(null, arguments, sig, true, wrapExceptions);
+ object[] arguments = CheckArguments(parameters, binder, invokeAttr, culture, sig);
+ object retValue = RuntimeMethodHandle.InvokeMethod(null, arguments, sig, true, wrapExceptions);
// copy out. This should be made only if ByRef are present.
for (int index = 0; index < arguments.Length; index++)
parameters[index] = arguments[index];
#endregion
#region Object Overrides
- public override String ToString()
+ public override string ToString()
{
if (m_addMethod == null || m_addMethod.GetParametersNoCopy().Length == 0)
throw new InvalidOperationException(SR.InvalidOperation_NoPublicAddMethod);
#endregion
#region ICustomAttributeProvider
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
if (attributeType == null)
throw new ArgumentNullException(nameof(attributeType));
#region MemberInfo Overrides
public override MemberTypes MemberType { get { return MemberTypes.Event; } }
- public override String Name
+ public override string Name
{
get
{
#endregion
#region Object Overrides
- public unsafe override String ToString()
+ public unsafe override string ToString()
{
return FieldType.FormatTypeName() + " " + Name;
}
#endregion
#region ICustomAttributeProvider
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
if (attributeType == null)
throw new ArgumentNullException(nameof(attributeType));
#endregion
#region Object Overrides
- public override String ToString()
+ public override string ToString()
{
if (m_toString == null)
m_toString = ReturnType.FormatTypeName() + " " + FormatNameAndSig();
#endregion
#region ICustomAttributeProvider
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType as RuntimeType, inherit);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
if (attributeType == null)
throw new ArgumentNullException(nameof(attributeType));
#endregion
#region MemberInfo Overrides
- public override String Name
+ public override string Name
{
get
{
#endregion
#region Invocation Logic(On MemberBase)
- private void CheckConsistency(Object target)
+ private void CheckConsistency(object target)
{
// only test instance methods
if ((m_methodAttributes & MethodAttributes.Static) != MethodAttributes.Static)
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public override Object Invoke(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
object[] arguments = InvokeArgumentsCheck(obj, invokeAttr, binder, parameters, culture);
return RuntimeMethodHandle.InvokeMethod(obj, null, Signature, false, wrapExceptions);
else
{
- Object retValue = RuntimeMethodHandle.InvokeMethod(obj, arguments, Signature, false, wrapExceptions);
+ object retValue = RuntimeMethodHandle.InvokeMethod(obj, arguments, Signature, false, wrapExceptions);
// copy out. This should be made only if ByRef are present.
for (int index = 0; index < arguments.Length; index++)
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- private object[] InvokeArgumentsCheck(Object obj, BindingFlags invokeAttr, Binder binder, Object[] parameters, CultureInfo culture)
+ private object[] InvokeArgumentsCheck(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
{
Signature sig = Signature;
DelegateBindingFlags.OpenDelegateOnly | DelegateBindingFlags.RelaxedSignature);
}
- public override Delegate CreateDelegate(Type delegateType, Object target)
+ public override Delegate CreateDelegate(Type delegateType, object target)
{
// This API is new in Whidbey and allows the full range of delegate
// flexability (open or closed delegates binding to static or
DelegateBindingFlags.RelaxedSignature);
}
- private Delegate CreateDelegateInternal(Type delegateType, Object firstArgument, DelegateBindingFlags bindingFlags)
+ private Delegate CreateDelegateInternal(Type delegateType, object firstArgument, DelegateBindingFlags bindingFlags)
{
// Validate the parameters.
if (delegateType == null)
#endregion
#region ICustomAttributeProvider Members
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
if (attributeType == null)
throw new ArgumentNullException(nameof(attributeType));
throw new ArgumentNullException(nameof(className));
RuntimeType retType = null;
- Object keepAlive = null;
+ object keepAlive = null;
GetType(GetNativeHandle(), className, throwOnError, ignoreCase, JitHelpers.GetObjectHandleOnStack(ref retType), JitHelpers.GetObjectHandleOnStack(ref keepAlive));
GC.KeepAlive(keepAlive);
return retType;
}
// ctor for no metadata MethodInfo in the DynamicMethod and RuntimeMethodInfo cases
- internal RuntimeParameterInfo(MethodInfo owner, String name, Type parameterType, int position)
+ internal RuntimeParameterInfo(MethodInfo owner, string name, Type parameterType, int position)
{
MemberImpl = owner;
NameImpl = name;
}
}
- public override String Name
+ public override string Name
{
get
{
}
}
- public override Object DefaultValue { get { return GetDefaultValue(false); } }
- public override Object RawDefaultValue { get { return GetDefaultValue(true); } }
+ public override object DefaultValue { get { return GetDefaultValue(false); } }
+ public override object RawDefaultValue { get { return GetDefaultValue(true); } }
- private Object GetDefaultValue(bool raw)
+ private object GetDefaultValue(bool raw)
{
// OLD COMMENT (Is this even true?)
// Cannot cache because default value could be non-agile user defined enumeration.
}
// returns DBNull.Value if the parameter doesn't have a default value
- private Object GetDefaultValueInternal(bool raw)
+ private object GetDefaultValueInternal(bool raw)
{
Debug.Assert(!m_noMetadata);
}
else
{
- Object[] CustomAttrs = GetCustomAttributes(s_CustomConstantAttributeType, false);
+ object[] CustomAttrs = GetCustomAttributes(s_CustomConstantAttributeType, false);
if (CustomAttrs.Length != 0)
{
defaultValue = ((CustomConstantAttribute)CustomAttrs[0]).Value;
return defaultValue;
}
- private static Decimal GetRawDecimalConstant(CustomAttributeData attr)
+ private static decimal GetRawDecimalConstant(CustomAttributeData attr)
{
Debug.Assert(attr.Constructor.DeclaringType == typeof(DecimalConstantAttribute));
{
// This is not possible because Decimal cannot be represented directly in the metadata.
Debug.Fail("Decimal cannot be represented directly in the metadata.");
- return (Decimal)namedArgument.TypedValue.Value;
+ return (decimal)namedArgument.TypedValue.Value;
}
}
if (parameters[2].ParameterType == typeof(uint))
{
// DecimalConstantAttribute(byte scale, byte sign, uint hi, uint mid, uint low)
- int low = (int)(UInt32)args[4].Value;
- int mid = (int)(UInt32)args[3].Value;
- int hi = (int)(UInt32)args[2].Value;
+ int low = (int)(uint)args[4].Value;
+ int mid = (int)(uint)args[3].Value;
+ int hi = (int)(uint)args[2].Value;
byte sign = (byte)args[1].Value;
byte scale = (byte)args[0].Value;
#endregion
#region ICustomAttributeProvider
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
if (MdToken.IsNullToken(m_tkParamDef))
- return Array.Empty<Object>();
+ return Array.Empty<object>();
return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
if (attributeType == null)
throw new ArgumentNullException(nameof(attributeType));
if (MdToken.IsNullToken(m_tkParamDef))
- return Array.Empty<Object>();
+ return Array.Empty<object>();
RuntimeType attributeRuntimeType = attributeType.UnderlyingSystemType as RuntimeType;
#endregion
#region Object Overrides
- public override String ToString()
+ public override string ToString()
{
return FormatNameAndSig(false);
}
#endregion
#region ICustomAttributeProvider
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
return CustomAttribute.GetCustomAttributes(this, typeof(object) as RuntimeType);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
if (attributeType == null)
throw new ArgumentNullException(nameof(attributeType));
#region MemberInfo Overrides
public override MemberTypes MemberType { get { return MemberTypes.Property; } }
- public override String Name
+ public override string Name
{
get
{
internal object GetConstantValue(bool raw)
{
- Object defaultValue = MdConstant.GetValue(GetRuntimeModule().MetadataImport, m_token, PropertyType.GetTypeHandleInternal(), raw);
+ object defaultValue = MdConstant.GetValue(GetRuntimeModule().MetadataImport, m_token, PropertyType.GetTypeHandleInternal(), raw);
if (defaultValue == DBNull.Value)
// Arg_EnumLitValueNotFound -> "Literal value was not found."
#region Dynamic
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public override Object GetValue(Object obj, Object[] index)
+ public override object GetValue(object obj, object[] index)
{
return GetValue(obj, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static,
null, index, null);
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public override Object GetValue(Object obj, BindingFlags invokeAttr, Binder binder, Object[] index, CultureInfo culture)
+ public override object GetValue(object obj, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
{
MethodInfo m = GetGetMethod(true);
if (m == null)
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public override void SetValue(Object obj, Object value, Object[] index)
+ public override void SetValue(object obj, object value, object[] index)
{
SetValue(obj,
value,
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public override void SetValue(Object obj, Object value, BindingFlags invokeAttr, Binder binder, Object[] index, CultureInfo culture)
+ public override void SetValue(object obj, object value, BindingFlags invokeAttr, Binder binder, object[] index, CultureInfo culture)
{
MethodInfo m = GetSetMethod(true);
if (m == null)
throw new ArgumentException(System.SR.Arg_SetMethNotFnd);
- Object[] args = null;
+ object[] args = null;
if (index != null)
{
- args = new Object[index.Length + 1];
+ args = new object[index.Length + 1];
for (int i = 0; i < index.Length; i++)
args[i] = index[i];
}
else
{
- args = new Object[1];
+ args = new object[1];
args[0] = value;
}
// Consider modifying IResourceGroveler interface (hence this method signature) when we figure out
// serialization compat story for moving ResourceManager members to either file-based or
// manifest-based classes. Want to continue tightening the design to get rid of unused params.
- public ResourceSet GrovelForResourceSet(CultureInfo culture, Dictionary<String, ResourceSet> localResourceSets, bool tryParents, bool createIfNotExists, ref StackCrawlMark stackMark)
+ public ResourceSet GrovelForResourceSet(CultureInfo culture, Dictionary<string, ResourceSet> localResourceSets, bool tryParents, bool createIfNotExists, ref StackCrawlMark stackMark)
{
Debug.Assert(culture != null, "culture shouldn't be null; check caller");
- String fileName = null;
+ string fileName = null;
ResourceSet rs = null;
// Don't use Assembly manifest, but grovel on disk for a file.
// Create new ResourceSet, if a file exists on disk for it.
- String tempFileName = _mediator.GetResourceFileName(culture);
+ string tempFileName = _mediator.GetResourceFileName(culture);
fileName = FindResourceFile(culture, tempFileName);
if (fileName == null)
{
// diretory or the module dir wasn't provided, look in the current
// directory.
- private String FindResourceFile(CultureInfo culture, String fileName)
+ private string FindResourceFile(CultureInfo culture, string fileName)
{
Debug.Assert(culture != null, "culture shouldn't be null; check caller");
Debug.Assert(fileName != null, "fileName shouldn't be null; check caller");
// qualified name, append path to that.
if (_mediator.ModuleDir != null)
{
- String path = Path.Combine(_mediator.ModuleDir, fileName);
+ string path = Path.Combine(_mediator.ModuleDir, fileName);
if (File.Exists(path))
{
return path;
}
// Constructs a new ResourceSet for a given file name.
- private ResourceSet CreateResourceSet(String file)
+ private ResourceSet CreateResourceSet(string file)
{
Debug.Assert(file != null, "file shouldn't be null; check caller");
}
else
{
- Object[] args = new Object[1];
+ object[] args = new object[1];
args[0] = file;
try
{
{
internal interface IResourceGroveler
{
- ResourceSet GrovelForResourceSet(CultureInfo culture, Dictionary<String, ResourceSet> localResourceSets, bool tryParents,
+ ResourceSet GrovelForResourceSet(CultureInfo culture, Dictionary<string, ResourceSet> localResourceSets, bool tryParents,
bool createIfNotExists, ref StackCrawlMark stackMark);
}
}
// Note we could go into infinite loops if mscorlib's
// NeutralResourcesLanguageAttribute is mangled. If this assert
// fires, please fix the build process for the BCL directory.
- if (a == typeof(Object).Assembly)
+ if (a == typeof(object).Assembly)
{
Debug.Fail(System.CoreLib.Name + "'s NeutralResourcesLanguageAttribute is a malformed culture name! name: \"" + cultureName + "\" Exception: " + e);
return CultureInfo.InvariantCulture;
// not disposing because we want to leave stream open
BinaryReader br = new BinaryReader(store);
- // Look for our magic number as a little endian Int32.
+ // Look for our magic number as a little endian int.
int bytes = br.ReadInt32();
if (bytes == ResourceManager.MagicNumber)
{
{
// we do not want to use partial binding here.
Type readerType = Type.GetType(readerTypeName, true);
- Object[] args = new Object[1];
+ object[] args = new object[1];
args[0] = store;
IResourceReader reader = (IResourceReader)Activator.CreateInstance(readerType, args);
- Object[] resourceSetArgs = new Object[1];
+ object[] resourceSetArgs = new object[1];
resourceSetArgs[0] = reader;
Type resSetType;
}
else
{
- Object[] args = new Object[2];
+ object[] args = new object[2];
args[0] = store;
args[1] = assembly;
try
}
catch (MissingMethodException) { }
- args = new Object[1];
+ args = new object[1];
args[0] = store;
rs = (ResourceSet)Activator.CreateInstance(_mediator.UserResourceSet, args);
private void HandleResourceStreamMissing(string fileName)
{
// Keep people from bothering me about resources problems
- if (_mediator.MainAssembly == typeof(Object).Assembly && _mediator.BaseName.Equals(System.CoreLib.Name))
+ if (_mediator.MainAssembly == typeof(object).Assembly && _mediator.BaseName.Equals(System.CoreLib.Name))
{
// This would break CultureInfo & all our exceptions.
Debug.Fail("Couldn't get " + System.CoreLib.Name + ResourceManager.ResFileExtension + " from " + System.CoreLib.Name + "'s assembly" + Environment.NewLine + Environment.NewLine + "Are you building the runtime on your machine? Chances are the BCL directory didn't build correctly. Type 'build -c' in the BCL directory. If you get build errors, look at buildd.log. If you then can't figure out what's wrong (and you aren't changing the assembly-related metadata code), ask a BCL dev.\n\nIf you did NOT build the runtime, you shouldn't be seeing this and you've found a bug.");
// This isn't for security reasons, but to ensure we can make
// breaking changes to mscorlib's internal resources without
// assuming users may have taken a dependency on them.
- if (assembly == typeof(Object).Assembly && _callingAssembly != assembly)
+ if (assembly == typeof(object).Assembly && _callingAssembly != assembly)
{
_callingAssembly = null;
}
// This isn't for security reasons, but to ensure we can make
// breaking changes to mscorlib's internal resources without
// assuming users may have taken a dependency on them.
- if (assembly == typeof(Object).Assembly && _callingAssembly != assembly)
+ if (assembly == typeof(object).Assembly && _callingAssembly != assembly)
_callingAssembly = null;
}
_callingAssembly = (RuntimeAssembly)Assembly.GetCallingAssembly();
// Special case for mscorlib - protect mscorlib's private resources.
- if (MainAssembly == typeof(Object).Assembly && _callingAssembly != MainAssembly)
+ if (MainAssembly == typeof(object).Assembly && _callingAssembly != MainAssembly)
{
_callingAssembly = null;
}
ResourceSet lostRace;
if (localResourceSets.TryGetValue(cultureName, out lostRace))
{
- if (!Object.ReferenceEquals(lostRace, rs))
+ if (!object.ReferenceEquals(lostRace, rs))
{
// Note: In certain cases, we can be trying to add a ResourceSet for multiple
// cultures on one thread, while a second thread added another ResourceSet for one
// Now, compare assembly display names (IGNORES VERSION AND PROCESSORARCHITECTURE)
// also, for mscorlib ignores everything, since that's what the binder is going to do
- while (Char.IsWhiteSpace(asmTypeName1[++comma])) ;
+ while (char.IsWhiteSpace(asmTypeName1[++comma])) ;
// case insensitive
AssemblyName an1 = new AssemblyName(asmTypeName1.Substring(comma));
// contains the PRI resources.
private bool ShouldUseSatelliteAssemblyResourceLookupUnderAppX(RuntimeAssembly resourcesAssembly)
{
- bool fUseSatelliteAssemblyResourceLookupUnderAppX = typeof(Object).Assembly == resourcesAssembly;
+ bool fUseSatelliteAssemblyResourceLookupUnderAppX = typeof(object).Assembly == resourcesAssembly;
if (!fUseSatelliteAssemblyResourceLookupUnderAppX)
{
if (resourcesAssembly != null)
{
- if (resourcesAssembly != typeof(Object).Assembly) // We are not loading resources for mscorlib
+ if (resourcesAssembly != typeof(object).Assembly) // We are not loading resources for mscorlib
{
// Cannot load the WindowsRuntimeResourceManager when in a compilation process, since it
// lives in System.Runtime.WindowsRuntime and only mscorlib may be loaded for execution.
// match, since CultureInfo objects can't represent all the different languages the AppX resource model supports.
// For classic resources, this causes us to ignore the languages list and instead use the older Win32 behavior,
// which is the design choice we've made. (See the call a little later to GetCurrentUICultureNoAppX()).
- if (Object.ReferenceEquals(culture, CultureInfo.CurrentUICulture))
+ if (object.ReferenceEquals(culture, CultureInfo.CurrentUICulture))
{
culture = null;
}
// current thread's CultureInfo, and if not found, all parent CultureInfos.
// Returns null if the resource wasn't found.
//
- public virtual Object GetObject(string name)
+ public virtual object GetObject(string name)
{
return GetObject(name, (CultureInfo)null, true);
}
// Looks up a resource value for a particular name. Looks in the
// specified CultureInfo, and if not found, all parent CultureInfos.
// Returns null if the resource wasn't found.
- public virtual Object GetObject(string name, CultureInfo culture)
+ public virtual object GetObject(string name, CultureInfo culture)
{
return GetObject(name, culture, true);
}
- private Object GetObject(string name, CultureInfo culture, bool wrapUnmanagedMemStream)
+ private object GetObject(string name, CultureInfo culture, bool wrapUnmanagedMemStream)
{
if (null == name)
throw new ArgumentNullException(nameof(name));
// If the caller explictily passed in a culture that was obtained by calling CultureInfo.CurrentUICulture,
// null it out, so that we re-compute it based on the Win32 value and not the AppX language list value.
// (See the call a little later to GetCurrentUICultureNoAppX()).
- if (Object.ReferenceEquals(culture, CultureInfo.CurrentUICulture))
+ if (object.ReferenceEquals(culture, CultureInfo.CurrentUICulture))
{
culture = null;
}
ResourceSet last = GetFirstResourceSet(culture);
if (last != null)
{
- Object value = last.GetObject(name, _ignoreCase);
+ object value = last.GetObject(name, _ignoreCase);
if (value != null)
{
if (rs != last)
{
- Object value = rs.GetObject(name, _ignoreCase);
+ object value = rs.GetObject(name, _ignoreCase);
if (value != null)
{
// update the last used ResourceSet
public UnmanagedMemoryStream GetStream(string name, CultureInfo culture)
{
- Object obj = GetObject(name, culture, false);
+ object obj = GetObject(name, culture, false);
UnmanagedMemoryStream ums = obj as UnmanagedMemoryStream;
if (ums == null && obj != null)
throw new InvalidOperationException(SR.Format(SR.InvalidOperation_ResourceNotStream_Name, name));
internal struct ResourceLocator
{
- internal Object _value; // Can be null. Consider WeakReference instead?
+ internal object _value; // Can be null. Consider WeakReference instead?
internal int _dataPos;
- internal ResourceLocator(int dataPos, Object value)
+ internal ResourceLocator(int dataPos, object value)
{
_dataPos = dataPos;
_value = value;
// Allows adding in profiling data in a future version, or a special
// resource profiling build. We could also use WeakReference.
- internal Object Value
+ internal object Value
{
get { return _value; }
set { _value = value; }
// This is used in the enumerator. The enumerator iterates from 0 to n
// of our resources and this returns the resource value for a particular
// index. The parameter is NOT a virtual offset.
- private Object GetValueForNameIndex(int index)
+ private object GetValueForNameIndex(int index)
{
Debug.Assert(_store != null, "ResourceReader is closed!");
long nameVA = GetNamePosition(index);
}
// Called from RuntimeResourceSet
- internal Object LoadObject(int pos)
+ internal object LoadObject(int pos)
{
if (_version == 1)
return LoadObjectV1(pos);
return LoadObjectV2(pos, out typeCode);
}
- internal Object LoadObject(int pos, out ResourceTypeCode typeCode)
+ internal object LoadObject(int pos, out ResourceTypeCode typeCode)
{
if (_version == 1)
{
- Object o = LoadObjectV1(pos);
+ object o = LoadObjectV1(pos);
typeCode = (o is string) ? ResourceTypeCode.String : ResourceTypeCode.StartOfUserTypes;
return o;
}
// from that location.
// Anyone who calls LoadObject should make sure they take a lock so
// no one can cause us to do a seek in here.
- internal Object LoadObjectV1(int pos)
+ internal object LoadObjectV1(int pos)
{
Debug.Assert(_store != null, "ResourceReader is closed!");
Debug.Assert(_version == 1, ".resources file was not a V1 .resources file!");
}
}
- private Object _LoadObjectV1(int pos)
+ private object _LoadObjectV1(int pos)
{
_store.BaseStream.Seek(_dataSectionOffset + pos, SeekOrigin.Begin);
int typeIndex = _store.Read7BitEncodedInt();
if (type == typeof(string))
return _store.ReadString();
- else if (type == typeof(Int32))
+ else if (type == typeof(int))
return _store.ReadInt32();
- else if (type == typeof(Byte))
+ else if (type == typeof(byte))
return _store.ReadByte();
- else if (type == typeof(SByte))
+ else if (type == typeof(sbyte))
return _store.ReadSByte();
- else if (type == typeof(Int16))
+ else if (type == typeof(short))
return _store.ReadInt16();
- else if (type == typeof(Int64))
+ else if (type == typeof(long))
return _store.ReadInt64();
- else if (type == typeof(UInt16))
+ else if (type == typeof(ushort))
return _store.ReadUInt16();
- else if (type == typeof(UInt32))
+ else if (type == typeof(uint))
return _store.ReadUInt32();
- else if (type == typeof(UInt64))
+ else if (type == typeof(ulong))
return _store.ReadUInt64();
- else if (type == typeof(Single))
+ else if (type == typeof(float))
return _store.ReadSingle();
- else if (type == typeof(Double))
+ else if (type == typeof(double))
return _store.ReadDouble();
else if (type == typeof(DateTime))
{
}
else if (type == typeof(TimeSpan))
return new TimeSpan(_store.ReadInt64());
- else if (type == typeof(Decimal))
+ else if (type == typeof(decimal))
{
int[] bits = new int[4];
for (int i = 0; i < bits.Length; i++)
bits[i] = _store.ReadInt32();
- return new Decimal(bits);
+ return new decimal(bits);
}
else
{
}
}
- internal Object LoadObjectV2(int pos, out ResourceTypeCode typeCode)
+ internal object LoadObjectV2(int pos, out ResourceTypeCode typeCode)
{
Debug.Assert(_store != null, "ResourceReader is closed!");
Debug.Assert(_version >= 2, ".resources file was not a V2 (or higher) .resources file!");
}
}
- private Object _LoadObjectV2(int pos, out ResourceTypeCode typeCode)
+ private object _LoadObjectV2(int pos, out ResourceTypeCode typeCode)
{
_store.BaseStream.Seek(_dataSectionOffset + pos, SeekOrigin.Begin);
typeCode = (ResourceTypeCode)_store.Read7BitEncodedInt();
case ResourceTypeCode.DateTime:
// Use DateTime's ToBinary & FromBinary.
- Int64 data = _store.ReadInt64();
+ long data = _store.ReadInt64();
return DateTime.FromBinary(data);
case ResourceTypeCode.TimeSpan:
- Int64 ticks = _store.ReadInt64();
+ long ticks = _store.ReadInt64();
return new TimeSpan(ticks);
// Special types
internal sealed class ResourceEnumerator : IDictionaryEnumerator
{
- private const int ENUM_DONE = Int32.MinValue;
+ private const int ENUM_DONE = int.MinValue;
private const int ENUM_NOT_STARTED = -1;
private ResourceReader _reader;
return true;
}
- public Object Key
+ public object Key
{
get
{
}
}
- public Object Current
+ public object Current
{
get
{
if (_reader._resCache == null) throw new InvalidOperationException(SR.ResourceReaderIsClosed);
string key;
- Object value = null;
+ object value = null;
lock (_reader)
{ // locks should be taken in the same order as in RuntimeResourceSet.GetObject to avoid deadlock
lock (_reader._resCache)
}
}
- public Object Value
+ public object Value
{
get
{
// implementation. Use this constructor to open & read from a file
// on disk.
//
- public ResourceSet(String fileName)
+ public ResourceSet(string fileName)
{
Reader = new ResourceReader(fileName);
CommonInit();
// Look up a string value for a resource given its name.
//
- public virtual String GetString(String name)
+ public virtual string GetString(string name)
{
- Object obj = GetObjectInternal(name);
+ object obj = GetObjectInternal(name);
try
{
- return (String)obj;
+ return (string)obj;
}
catch (InvalidCastException)
{
}
}
- public virtual String GetString(String name, bool ignoreCase)
+ public virtual string GetString(string name, bool ignoreCase)
{
- Object obj;
- String s;
+ object obj;
+ string s;
// Case-sensitive lookup
obj = GetObjectInternal(name);
try
{
- s = (String)obj;
+ s = (string)obj;
}
catch (InvalidCastException)
{
obj = GetCaseInsensitiveObjectInternal(name);
try
{
- return (String)obj;
+ return (string)obj;
}
catch (InvalidCastException)
{
// Look up an object value for a resource given its name.
//
- public virtual Object GetObject(String name)
+ public virtual object GetObject(string name)
{
return GetObjectInternal(name);
}
- public virtual Object GetObject(String name, bool ignoreCase)
+ public virtual object GetObject(string name, bool ignoreCase)
{
- Object obj = GetObjectInternal(name);
+ object obj = GetObjectInternal(name);
if (obj != null || !ignoreCase)
return obj;
IDictionaryEnumerator en = Reader.GetEnumerator();
while (en.MoveNext())
{
- Object value = en.Value;
+ object value = en.Value;
Table.Add(en.Key, value);
}
// While technically possible to close the Reader here, don't close it
// to help with some WinRes lifetime issues.
}
- private Object GetObjectInternal(String name)
+ private object GetObjectInternal(string name)
{
if (name == null)
throw new ArgumentNullException(nameof(name));
return copyOfTable[name];
}
- private Object GetCaseInsensitiveObjectInternal(String name)
+ private object GetCaseInsensitiveObjectInternal(string name)
{
Hashtable copyOfTable = Table; // Avoid a race with Dispose
// see how it compares to the current implementation.
// This delegate will disappear at some point in favor of calli
- internal delegate void CtorDelegate(Object instance);
+ internal delegate void CtorDelegate(object instance);
// Keep this in sync with FormatFlags defined in typestring.h
internal enum TypeNameFormatFlags
return _items;
}
- public void CopyTo(Object[] array, int index)
+ public void CopyTo(object[] array, int index)
{
if (_count == 0)
return;
Encoding.UTF8.GetBytes(pName, cNameLen, pUtf8Name, cUtf8Name);
Filter filter = new Filter(pUtf8Name, cUtf8Name, listType);
- Object list = null;
+ object list = null;
switch (cacheType)
{
private MemberInfoCache<RuntimePropertyInfo> m_propertyInfoCache;
private MemberInfoCache<RuntimeEventInfo> m_eventInfoCache;
private static CerHashtable<RuntimeMethodInfo, RuntimeMethodInfo> s_methodInstantiations;
- private static Object s_methodInstantiationsLock;
+ private static object s_methodInstantiationsLock;
private string m_defaultMemberName;
- private Object m_genericCache; // Generic cache for rare scenario specific data. It is used to cache Enum names and values.
+ private object m_genericCache; // Generic cache for rare scenario specific data. It is used to cache Enum names and values.
#endregion
#region Constructor
#region Internal Members
- internal Object GenericCache
+ internal object GenericCache
{
get { return m_genericCache; }
set { m_genericCache = value; }
IList<CustomAttributeData> attrs = CustomAttributeData.GetCustomAttributes(t);
for (int i = 0; i < attrs.Count; i++)
{
- if (Object.ReferenceEquals(attrs[i].Constructor.DeclaringType, DefaultMemberAttrType))
+ if (object.ReferenceEquals(attrs[i].Constructor.DeclaringType, DefaultMemberAttrType))
{
attr = attrs[i];
break;
return crmi;
if (s_methodInstantiationsLock == null)
- Interlocked.CompareExchange(ref s_methodInstantiationsLock, new Object(), null);
+ Interlocked.CompareExchange(ref s_methodInstantiationsLock, new object(), null);
bool lockTaken = false;
RuntimeHelpers.PrepareConstrainedRegions();
return retval;
}
- internal Object GenericCache
+ internal object GenericCache
{
get { return Cache.GenericCache; }
set { Cache.GenericCache = value; }
}
#endregion
- bool isInherited = !Object.ReferenceEquals(memberInfo.DeclaringType, memberInfo.ReflectedType);
+ bool isInherited = !object.ReferenceEquals(memberInfo.DeclaringType, memberInfo.ReflectedType);
#region Filter by DeclaredOnly
if ((bindingFlags & BindingFlags.DeclaredOnly) != 0 && isInherited)
{
if (match != null)
{
- if (Object.ReferenceEquals(fieldInfo.DeclaringType, match.DeclaringType))
+ if (object.ReferenceEquals(fieldInfo.DeclaringType, match.DeclaringType))
throw new AmbiguousMatchException(SR.Arg_AmbiguousMatchException);
if ((match.DeclaringType.IsInterface == true) && (fieldInfo.DeclaringType.IsInterface == true))
#endregion
#region Hierarchy
- public override bool IsInstanceOfType(Object o)
+ public override bool IsInstanceOfType(object o)
{
return RuntimeTypeHandle.IsInstanceOfType(this, o);
}
if ((object)c == null)
return false;
- if (Object.ReferenceEquals(c, this))
+ if (object.ReferenceEquals(c, this))
return true;
RuntimeType fromType = c.UnderlyingSystemType as RuntimeType;
for (int i = 0; i < values.Length; i++)
{
- Object val = Enum.ToObject(this, values[i]);
+ object val = Enum.ToObject(this, values[i]);
ret.SetValue(val, i);
}
private static extern bool CanValueSpecialCast(RuntimeType valueType, RuntimeType targetType);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern Object AllocateValueType(RuntimeType type, object value, bool fForceTypeChange);
+ private static extern object AllocateValueType(RuntimeType type, object value, bool fForceTypeChange);
- internal unsafe Object CheckValue(Object value, Binder binder, CultureInfo culture, BindingFlags invokeAttr)
+ internal unsafe object CheckValue(object value, Binder binder, CultureInfo culture, BindingFlags invokeAttr)
{
// this method is used by invocation in reflection to check whether a value can be assigned to type.
if (IsInstanceOfType(value))
Type type = value.GetType();
- if (!Object.ReferenceEquals(type, this) && RuntimeTypeHandle.IsValueType(this))
+ if (!object.ReferenceEquals(type, this) && RuntimeTypeHandle.IsValueType(this))
{
// must be an equivalent type, re-box to the target type
return AllocateValueType(this, value, true);
}
// Factored out of CheckValue to reduce code complexity.
- private Object TryChangeType(Object value, Binder binder, CultureInfo culture, bool needsSpecialCast)
+ private object TryChangeType(object value, Binder binder, CultureInfo culture, bool needsSpecialCast)
{
if (binder != null && binder != Type.DefaultBinder)
{
#endif
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- public override Object InvokeMember(
- string name, BindingFlags bindingFlags, Binder binder, Object target,
- Object[] providedArgs, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParams)
+ public override object InvokeMember(
+ string name, BindingFlags bindingFlags, Binder binder, object target,
+ object[] providedArgs, ParameterModifier[] modifiers, CultureInfo culture, string[] namedParams)
{
if (IsGenericParameter)
throw new InvalidOperationException(SR.Arg_GenericParameter);
if (selFld != null)
{
#region Invocation on a field
- if (selFld.FieldType.IsArray || Object.ReferenceEquals(selFld.FieldType, typeof(System.Array)))
+ if (selFld.FieldType.IsArray || object.ReferenceEquals(selFld.FieldType, typeof(System.Array)))
{
#region Invocation of an array Field
int idxCnt;
finalists = new MethodInfo[] { finalist };
if (providedArgs == null)
- providedArgs = Array.Empty<Object>();
+ providedArgs = Array.Empty<object>();
- Object state = null;
+ object state = null;
MethodBase invokeMethod = null;
//if (useCache && argCnt == invokeMethod.GetParameters().Length)
// AddMethodToCache(name, bindingFlags, argCnt, providedArgs, invokeMethod);
- Object result = ((MethodInfo)invokeMethod).Invoke(target, bindingFlags, binder, providedArgs, culture);
+ object result = ((MethodInfo)invokeMethod).Invoke(target, bindingFlags, binder, providedArgs, culture);
if (state != null)
binder.ReorderArgumentArray(ref providedArgs, state);
#endregion
#region ICloneable
- public Object Clone()
+ public object Clone()
{
return this;
}
#endregion
#region ICustomAttributeProvider
- public override Object[] GetCustomAttributes(bool inherit)
+ public override object[] GetCustomAttributes(bool inherit)
{
return CustomAttribute.GetCustomAttributes(this, RuntimeType.ObjectType, inherit);
}
- public override Object[] GetCustomAttributes(Type attributeType, bool inherit)
+ public override object[] GetCustomAttributes(Type attributeType, bool inherit)
{
if ((object)attributeType == null)
throw new ArgumentNullException(nameof(attributeType));
Type elementType = this.GetRootElementType();
- if (Object.ReferenceEquals(elementType, typeof(ArgIterator)))
+ if (object.ReferenceEquals(elementType, typeof(ArgIterator)))
throw new NotSupportedException(SR.Acc_CreateArgIterator);
- if (Object.ReferenceEquals(elementType, typeof(void)))
+ if (object.ReferenceEquals(elementType, typeof(void)))
throw new NotSupportedException(SR.Acc_CreateVoid);
}
- internal Object CreateInstanceImpl(
- BindingFlags bindingAttr, Binder binder, Object[] args, CultureInfo culture, Object[] activationAttributes)
+ internal object CreateInstanceImpl(
+ BindingFlags bindingAttr, Binder binder, object[] args, CultureInfo culture, object[] activationAttributes)
{
CreateInstanceCheckThis();
- Object server = null;
+ object server = null;
if (args == null)
- args = Array.Empty<Object>();
+ args = Array.Empty<object>();
int argCnt = args.Length;
}
MethodBase invokeMethod;
- Object state = null;
+ object state = null;
try
{
private void InitializeDelegateCreator()
{
- ConstructorInfo ctorInfo = typeof(CtorDelegate).GetConstructor(new Type[] { typeof(Object), typeof(IntPtr) });
+ ConstructorInfo ctorInfo = typeof(CtorDelegate).GetConstructor(new Type[] { typeof(object), typeof(IntPtr) });
delegateCtorInfo = ctorInfo; // this assignment should be last
}
InitializeDelegateCreator();
// No synchronization needed here. In the worst case we create extra garbage
- CtorDelegate ctor = (CtorDelegate)delegateCtorInfo.Invoke(new Object[] { null, RuntimeMethodHandle.GetFunctionPointer(ace.m_hCtorMethodHandle) });
+ CtorDelegate ctor = (CtorDelegate)delegateCtorInfo.Invoke(new object[] { null, RuntimeMethodHandle.GetFunctionPointer(ace.m_hCtorMethodHandle) });
ace.m_ctor = ctor;
}
ace.m_bFullyInitialized = true;
private static volatile ActivatorCache s_ActivatorCache;
// the slow path of CreateInstanceDefaultCtor
- internal Object CreateInstanceSlow(bool publicOnly, bool wrapExceptions, bool skipCheckThis, bool fillCache)
+ internal object CreateInstanceSlow(bool publicOnly, bool wrapExceptions, bool skipCheckThis, bool fillCache)
{
RuntimeMethodHandleInternal runtime_ctor = default;
bool bCanBeCached = false;
if (!skipCheckThis)
CreateInstanceCheckThis();
- Object instance = RuntimeTypeHandle.CreateInstance(this, publicOnly, wrapExceptions, ref bCanBeCached, ref runtime_ctor);
+ object instance = RuntimeTypeHandle.CreateInstance(this, publicOnly, wrapExceptions, ref bCanBeCached, ref runtime_ctor);
if (bCanBeCached && fillCache)
{
// fillCache is set in the SL2/3 compat mode or when called from Marshal.PtrToStructure.
[DebuggerStepThroughAttribute]
[Diagnostics.DebuggerHidden]
- internal Object CreateInstanceDefaultCtor(bool publicOnly, bool skipCheckThis, bool fillCache, bool wrapExceptions)
+ internal object CreateInstanceDefaultCtor(bool publicOnly, bool skipCheckThis, bool fillCache, bool wrapExceptions)
{
if (GetType() == typeof(ReflectionOnlyType))
throw new InvalidOperationException(SR.InvalidOperation_NotAllowedInReflectionOnly);
}
// Allocate empty object
- Object instance = RuntimeTypeHandle.Allocate(this);
+ object instance = RuntimeTypeHandle.Allocate(this);
// if m_ctor is null, this type doesn't have a default ctor
Debug.Assert(ace.m_ctor != null || this.IsValueType);
#region Legacy internal static
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern Object _CreateEnum(RuntimeType enumType, long value);
- internal static Object CreateEnum(RuntimeType enumType, long value)
+ private static extern object _CreateEnum(RuntimeType enumType, long value);
+ internal static object CreateEnum(RuntimeType enumType, long value)
{
return _CreateEnum(enumType, value);
}
#if FEATURE_COMINTEROP
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private extern Object InvokeDispMethod(
- string name, BindingFlags invokeAttr, Object target, Object[] args,
+ private extern object InvokeDispMethod(
+ string name, BindingFlags invokeAttr, object target, object[] args,
bool[] byrefModifiers, int culture, string[] namedParameters);
#endif // FEATURE_COMINTEROP
// is recognized and optimized by both 32-bit and 64-bit JITs.
// For Boolean, we cache all possible values.
- if (typeof(TResult) == typeof(Boolean)) // only the relevant branches are kept for each value-type generic instantiation
+ if (typeof(TResult) == typeof(bool)) // only the relevant branches are kept for each value-type generic instantiation
{
- Boolean value = (Boolean)(object)result;
- Task<Boolean> task = value ? AsyncTaskCache.TrueTask : AsyncTaskCache.FalseTask;
+ bool value = (bool)(object)result;
+ Task<bool> task = value ? AsyncTaskCache.TrueTask : AsyncTaskCache.FalseTask;
return Unsafe.As<Task<TResult>>(task); // UnsafeCast avoids type check we know will succeed
}
// For Int32, we cache a range of common values, e.g. [-1,4).
- else if (typeof(TResult) == typeof(Int32))
+ else if (typeof(TResult) == typeof(int))
{
// Compare to constants to avoid static field access if outside of cached range.
// We compare to the upper bound first, as we're more likely to cache miss on the upper side than on the
// lower side, due to positive values being more common than negative as return values.
- Int32 value = (Int32)(object)result;
+ int value = (int)(object)result;
if (value < AsyncTaskCache.EXCLUSIVE_INT32_MAX &&
value >= AsyncTaskCache.INCLUSIVE_INT32_MIN)
{
- Task<Int32> task = AsyncTaskCache.Int32Tasks[value - AsyncTaskCache.INCLUSIVE_INT32_MIN];
+ Task<int> task = AsyncTaskCache.Int32Tasks[value - AsyncTaskCache.INCLUSIVE_INT32_MIN];
return Unsafe.As<Task<TResult>>(task); // UnsafeCast avoids a type check we know will succeed
}
}
// For other known value types, we only special-case 0 / default(TResult).
else if (
- (typeof(TResult) == typeof(UInt32) && default == (UInt32)(object)result) ||
- (typeof(TResult) == typeof(Byte) && default(Byte) == (Byte)(object)result) ||
- (typeof(TResult) == typeof(SByte) && default(SByte) == (SByte)(object)result) ||
- (typeof(TResult) == typeof(Char) && default(Char) == (Char)(object)result) ||
- (typeof(TResult) == typeof(Int64) && default == (Int64)(object)result) ||
- (typeof(TResult) == typeof(UInt64) && default == (UInt64)(object)result) ||
- (typeof(TResult) == typeof(Int16) && default(Int16) == (Int16)(object)result) ||
- (typeof(TResult) == typeof(UInt16) && default(UInt16) == (UInt16)(object)result) ||
+ (typeof(TResult) == typeof(uint) && default == (uint)(object)result) ||
+ (typeof(TResult) == typeof(byte) && default(byte) == (byte)(object)result) ||
+ (typeof(TResult) == typeof(sbyte) && default(sbyte) == (sbyte)(object)result) ||
+ (typeof(TResult) == typeof(char) && default(char) == (char)(object)result) ||
+ (typeof(TResult) == typeof(long) && default == (long)(object)result) ||
+ (typeof(TResult) == typeof(ulong) && default == (ulong)(object)result) ||
+ (typeof(TResult) == typeof(short) && default(short) == (short)(object)result) ||
+ (typeof(TResult) == typeof(ushort) && default(ushort) == (ushort)(object)result) ||
(typeof(TResult) == typeof(IntPtr) && default == (IntPtr)(object)result) ||
(typeof(TResult) == typeof(UIntPtr) && default == (UIntPtr)(object)result))
{
// All static members are initialized inline to ensure type is beforefieldinit
/// <summary>A cached Task{Boolean}.Result == true.</summary>
- internal readonly static Task<Boolean> TrueTask = CreateCacheableTask(true);
+ internal readonly static Task<bool> TrueTask = CreateCacheableTask(true);
/// <summary>A cached Task{Boolean}.Result == false.</summary>
- internal readonly static Task<Boolean> FalseTask = CreateCacheableTask(false);
+ internal readonly static Task<bool> FalseTask = CreateCacheableTask(false);
/// <summary>The cache of Task{Int32}.</summary>
- internal readonly static Task<Int32>[] Int32Tasks = CreateInt32Tasks();
+ internal readonly static Task<int>[] Int32Tasks = CreateInt32Tasks();
/// <summary>The minimum value, inclusive, for which we want a cached task.</summary>
- internal const Int32 INCLUSIVE_INT32_MIN = -1;
+ internal const int INCLUSIVE_INT32_MIN = -1;
/// <summary>The maximum value, exclusive, for which we want a cached task.</summary>
- internal const Int32 EXCLUSIVE_INT32_MAX = 9;
+ internal const int EXCLUSIVE_INT32_MAX = 9;
/// <summary>Creates an array of cached tasks for the values in the range [INCLUSIVE_MIN,EXCLUSIVE_MAX).</summary>
- private static Task<Int32>[] CreateInt32Tasks()
+ private static Task<int>[] CreateInt32Tasks()
{
Debug.Assert(EXCLUSIVE_INT32_MAX >= INCLUSIVE_INT32_MIN, "Expected max to be at least min");
- var tasks = new Task<Int32>[EXCLUSIVE_INT32_MAX - INCLUSIVE_INT32_MIN];
+ var tasks = new Task<int>[EXCLUSIVE_INT32_MAX - INCLUSIVE_INT32_MIN];
for (int i = 0; i < tasks.Length; i++)
{
tasks[i] = CreateCacheableTask(i + INCLUSIVE_INT32_MIN);
//
// - Used with live key (linked into a bucket list where _buckets[hashCode & (_buckets.Length - 1)] points to first entry)
// depHnd.IsAllocated == true, depHnd.GetPrimary() != null
- // hashCode == RuntimeHelpers.GetHashCode(depHnd.GetPrimary()) & Int32.MaxValue
+ // hashCode == RuntimeHelpers.GetHashCode(depHnd.GetPrimary()) & int.MaxValue
// next links to next Entry in bucket.
//
// - Used with dead key (linked into a bucket list where _buckets[hashCode & (_buckets.Length - 1)] points to first entry)
{
// Exposed here as a more appropriate place than on FormatterServices itself,
// which is a high level reflection heavy type.
- public static Object GetUninitializedObject(Type type)
+ public static object GetUninitializedObject(Type type)
{
return FormatterServices.GetUninitializedObject(type);
}
// Of course, reference types are not cloned.
//
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern Object GetObjectValue(Object obj);
+ public static extern object GetObjectValue(object obj);
// RunClassConstructor causes the class constructor for the given type to be triggered
// in the current domain. After this call returns, the class constructor is guaranteed to
public static extern void PrepareDelegate(Delegate d);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern int GetHashCode(Object o);
+ public static extern int GetHashCode(object o);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public new static extern bool Equals(Object o1, Object o2);
+ public new static extern bool Equals(object o1, object o2);
public static int OffsetToStringData
{
{
}
- public delegate void TryCode(Object userData);
+ public delegate void TryCode(object userData);
- public delegate void CleanupCode(Object userData, bool exceptionThrown);
+ public delegate void CleanupCode(object userData, bool exceptionThrown);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern void ExecuteCodeWithGuaranteedCleanup(TryCode code, CleanupCode backoutCode, Object userData);
+ public static extern void ExecuteCodeWithGuaranteedCleanup(TryCode code, CleanupCode backoutCode, object userData);
- internal static void ExecuteBackoutCodeHelper(Object backoutCode, Object userData, bool exceptionThrown)
+ internal static void ExecuteBackoutCodeHelper(object backoutCode, object userData, bool exceptionThrown)
{
((CleanupCode)backoutCode)(userData, exceptionThrown);
}
// Set the given element in the array without any type or range checks
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern void UnsafeSetArrayElement(Object[] target, int index, Object element);
+ internal static extern void UnsafeSetArrayElement(object[] target, int index, object element);
// Used for unsafe pinning of arbitrary objects.
- internal static PinningHelper GetPinningHelper(Object o)
+ internal static PinningHelper GetPinningHelper(object o)
{
return Unsafe.As<PinningHelper>(o);
}
private object m_stackTrace;
private object m_dynamicMethods;
private UIntPtr m_IPForWatsonBuckets;
- private Object m_WatsonBuckets;
+ private object m_WatsonBuckets;
private ExceptionDispatchInfo(Exception exception)
{
// throw new Exception();
//}
- public ArrayWithOffset(Object array, int offset)
+ public ArrayWithOffset(object array, int offset)
{
m_array = array;
m_offset = offset;
m_count = CalculateCount();
}
- public Object GetArray()
+ public object GetArray()
{
return m_array;
}
return m_count + m_offset;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj is ArrayWithOffset)
return Equals((ArrayWithOffset)obj);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private extern int CalculateCount();
- private Object m_array;
+ private object m_array;
private int m_offset;
private int m_count;
}
public TypeIdentifierAttribute() { }
public TypeIdentifierAttribute(string scope, string identifier) { Scope_ = scope; Identifier_ = identifier; }
- public String Scope { get { return Scope_; } }
- public String Identifier { get { return Identifier_; } }
+ public string Scope { get { return Scope_; } }
+ public string Identifier { get { return Identifier_; } }
- internal String Scope_;
- internal String Identifier_;
+ internal string Scope_;
+ internal string Identifier_;
}
// To be used on methods that sink reverse P/Invoke calls.
[AttributeUsage(AttributeTargets.Class, Inherited = false)]
public sealed class ProgIdAttribute : Attribute
{
- internal String _val;
- public ProgIdAttribute(String progId)
+ internal string _val;
+ public ProgIdAttribute(string progId)
{
_val = progId;
}
- public String Value { get { return _val; } }
+ public string Value { get { return _val; } }
}
[AttributeUsage(AttributeTargets.Class, Inherited = true)]
public sealed class ComSourceInterfacesAttribute : Attribute
{
- internal String _val;
- public ComSourceInterfacesAttribute(String sourceInterfaces)
+ internal string _val;
+ public ComSourceInterfacesAttribute(string sourceInterfaces)
{
_val = sourceInterfaces;
}
{
_val = sourceInterface1.FullName + "\0" + sourceInterface2.FullName + "\0" + sourceInterface3.FullName + "\0" + sourceInterface4.FullName;
}
- public String Value { get { return _val; } }
+ public string Value { get { return _val; } }
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, Inherited = false)]
{
public sealed class BStrWrapper
{
- public BStrWrapper(String value)
+ public BStrWrapper(string value)
{
m_WrappedObject = value;
}
- public BStrWrapper(Object value)
+ public BStrWrapper(object value)
{
- m_WrappedObject = (String)value;
+ m_WrappedObject = (string)value;
}
- public String WrappedObject
+ public string WrappedObject
{
get
{
}
}
- private String m_WrappedObject;
+ private string m_WrappedObject;
}
}
HResult = HResults.E_FAIL;
}
- public COMException(String message)
+ public COMException(string message)
: base(message)
{
HResult = HResults.E_FAIL;
}
- public COMException(String message, Exception inner)
+ public COMException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.E_FAIL;
}
- public COMException(String message, int errorCode)
+ public COMException(string message, int errorCode)
: base(message)
{
HResult = errorCode;
{
}
- public override String ToString()
+ public override string ToString()
{
- String message = Message;
- String s;
- String _className = GetType().ToString();
+ string message = Message;
+ string s;
+ string _className = GetType().ToString();
s = _className + " (0x" + HResult.ToString("X8", CultureInfo.InvariantCulture) + ")";
if (!(message == null || message.Length <= 0))
[ComImport]
public interface IBindCtx
{
- void RegisterObjectBound([MarshalAs(UnmanagedType.Interface)] Object punk);
- void RevokeObjectBound([MarshalAs(UnmanagedType.Interface)] Object punk);
+ void RegisterObjectBound([MarshalAs(UnmanagedType.Interface)] object punk);
+ void RevokeObjectBound([MarshalAs(UnmanagedType.Interface)] object punk);
void ReleaseBoundObjects();
void SetBindOptions([In()] ref BIND_OPTS pbindopts);
void GetBindOptions(ref BIND_OPTS pbindopts);
void GetRunningObjectTable(out IRunningObjectTable pprot);
- void RegisterObjectParam([MarshalAs(UnmanagedType.LPWStr)] String pszKey, [MarshalAs(UnmanagedType.Interface)] Object punk);
- void GetObjectParam([MarshalAs(UnmanagedType.LPWStr)] String pszKey, [MarshalAs(UnmanagedType.Interface)] out Object ppunk);
+ void RegisterObjectParam([MarshalAs(UnmanagedType.LPWStr)] string pszKey, [MarshalAs(UnmanagedType.Interface)] object punk);
+ void GetObjectParam([MarshalAs(UnmanagedType.LPWStr)] string pszKey, [MarshalAs(UnmanagedType.Interface)] out object ppunk);
void EnumObjectParam(out IEnumString ppenum);
[PreserveSig]
- int RevokeObjectParam([MarshalAs(UnmanagedType.LPWStr)] String pszKey);
+ int RevokeObjectParam([MarshalAs(UnmanagedType.LPWStr)] string pszKey);
}
}
{
void GetConnectionInterface(out Guid pIID);
void GetConnectionPointContainer(out IConnectionPointContainer ppCPC);
- void Advise([MarshalAs(UnmanagedType.Interface)] Object pUnkSink, out int pdwCookie);
+ void Advise([MarshalAs(UnmanagedType.Interface)] object pUnkSink, out int pdwCookie);
void Unadvise(int dwCookie);
void EnumConnections(out IEnumConnections ppEnum);
}
public struct CONNECTDATA
{
[MarshalAs(UnmanagedType.Interface)]
- public Object pUnk;
+ public object pUnk;
public int dwCookie;
}
public interface IEnumString
{
[PreserveSig]
- int Next(int celt, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr, SizeParamIndex = 0), Out] String[] rgelt, IntPtr pceltFetched);
+ int Next(int celt, [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr, SizeParamIndex = 0), Out] string[] rgelt, IntPtr pceltFetched);
[PreserveSig]
int Skip(int celt);
void Reset();
int IsDirty();
void Load(IStream pStm);
void Save(IStream pStm, [MarshalAs(UnmanagedType.Bool)] bool fClearDirty);
- void GetSizeMax(out Int64 pcbSize);
+ void GetSizeMax(out long pcbSize);
// IMoniker portion
- void BindToObject(IBindCtx pbc, IMoniker pmkToLeft, [In()] ref Guid riidResult, [MarshalAs(UnmanagedType.Interface)] out Object ppvResult);
- void BindToStorage(IBindCtx pbc, IMoniker pmkToLeft, [In()] ref Guid riid, [MarshalAs(UnmanagedType.Interface)] out Object ppvObj);
+ void BindToObject(IBindCtx pbc, IMoniker pmkToLeft, [In()] ref Guid riidResult, [MarshalAs(UnmanagedType.Interface)] out object ppvResult);
+ void BindToStorage(IBindCtx pbc, IMoniker pmkToLeft, [In()] ref Guid riid, [MarshalAs(UnmanagedType.Interface)] out object ppvObj);
void Reduce(IBindCtx pbc, int dwReduceHowFar, ref IMoniker ppmkToLeft, out IMoniker ppmkReduced);
void ComposeWith(IMoniker pmkRight, [MarshalAs(UnmanagedType.Bool)] bool fOnlyIfNotGeneric, out IMoniker ppmkComposite);
void Enum([MarshalAs(UnmanagedType.Bool)] bool fForward, out IEnumMoniker ppenumMoniker);
void Inverse(out IMoniker ppmk);
void CommonPrefixWith(IMoniker pmkOther, out IMoniker ppmkPrefix);
void RelativePathTo(IMoniker pmkOther, out IMoniker ppmkRelPath);
- void GetDisplayName(IBindCtx pbc, IMoniker pmkToLeft, [MarshalAs(UnmanagedType.LPWStr)] out String ppszDisplayName);
- void ParseDisplayName(IBindCtx pbc, IMoniker pmkToLeft, [MarshalAs(UnmanagedType.LPWStr)] String pszDisplayName, out int pchEaten, out IMoniker ppmkOut);
+ void GetDisplayName(IBindCtx pbc, IMoniker pmkToLeft, [MarshalAs(UnmanagedType.LPWStr)] out string ppszDisplayName);
+ void ParseDisplayName(IBindCtx pbc, IMoniker pmkToLeft, [MarshalAs(UnmanagedType.LPWStr)] string pszDisplayName, out int pchEaten, out IMoniker ppmkOut);
[PreserveSig]
int IsSystemMoniker(out int pdwMksys);
}
// IPersistFile portion
[PreserveSig]
int IsDirty();
- void Load([MarshalAs(UnmanagedType.LPWStr)] String pszFileName, int dwMode);
- void Save([MarshalAs(UnmanagedType.LPWStr)] String pszFileName, [MarshalAs(UnmanagedType.Bool)] bool fRemember);
- void SaveCompleted([MarshalAs(UnmanagedType.LPWStr)] String pszFileName);
- void GetCurFile([MarshalAs(UnmanagedType.LPWStr)] out String ppszFileName);
+ void Load([MarshalAs(UnmanagedType.LPWStr)] string pszFileName, int dwMode);
+ void Save([MarshalAs(UnmanagedType.LPWStr)] string pszFileName, [MarshalAs(UnmanagedType.Bool)] bool fRemember);
+ void SaveCompleted([MarshalAs(UnmanagedType.LPWStr)] string pszFileName);
+ void GetCurFile([MarshalAs(UnmanagedType.LPWStr)] out string ppszFileName);
}
}
[ComImport]
public interface IRunningObjectTable
{
- int Register(int grfFlags, [MarshalAs(UnmanagedType.Interface)] Object punkObject, IMoniker pmkObjectName);
+ int Register(int grfFlags, [MarshalAs(UnmanagedType.Interface)] object punkObject, IMoniker pmkObjectName);
void Revoke(int dwRegister);
[PreserveSig]
int IsRunning(IMoniker pmkObjectName);
[PreserveSig]
- int GetObject(IMoniker pmkObjectName, [MarshalAs(UnmanagedType.Interface)] out Object ppunkObject);
+ int GetObject(IMoniker pmkObjectName, [MarshalAs(UnmanagedType.Interface)] out object ppunkObject);
void NoteChangeTime(int dwRegister, ref FILETIME pfiletime);
[PreserveSig]
int GetTimeOfLastChange(IMoniker pmkObjectName, out FILETIME pfiletime);
public struct STATSTG
{
- public String pwcsName;
+ public string pwcsName;
public int type;
- public Int64 cbSize;
+ public long cbSize;
public FILETIME mtime;
public FILETIME ctime;
public FILETIME atime;
public interface IStream
{
// ISequentialStream portion
- void Read([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1), Out] Byte[] pv, int cb, IntPtr pcbRead);
- void Write([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] Byte[] pv, int cb, IntPtr pcbWritten);
+ void Read([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1), Out] byte[] pv, int cb, IntPtr pcbRead);
+ void Write([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] byte[] pv, int cb, IntPtr pcbWritten);
// IStream portion
- void Seek(Int64 dlibMove, int dwOrigin, IntPtr plibNewPosition);
- void SetSize(Int64 libNewSize);
- void CopyTo(IStream pstm, Int64 cb, IntPtr pcbRead, IntPtr pcbWritten);
+ void Seek(long dlibMove, int dwOrigin, IntPtr plibNewPosition);
+ void SetSize(long libNewSize);
+ void CopyTo(IStream pstm, long cb, IntPtr pcbRead, IntPtr pcbWritten);
void Commit(int grfCommitFlags);
void Revert();
- void LockRegion(Int64 libOffset, Int64 cb, int dwLockType);
- void UnlockRegion(Int64 libOffset, Int64 cb, int dwLockType);
+ void LockRegion(long libOffset, long cb, int dwLockType);
+ void UnlockRegion(long libOffset, long cb, int dwLockType);
void Stat(out STATSTG pstatstg, int grfStatFlag);
void Clone(out IStream ppstm);
}
[ComImport]
public interface ITypeComp
{
- void Bind([MarshalAs(UnmanagedType.LPWStr)] String szName, int lHashVal, Int16 wFlags, out ITypeInfo ppTInfo, out DESCKIND pDescKind, out BINDPTR pBindPtr);
- void BindType([MarshalAs(UnmanagedType.LPWStr)] String szName, int lHashVal, out ITypeInfo ppTInfo, out ITypeComp ppTComp);
+ void Bind([MarshalAs(UnmanagedType.LPWStr)] string szName, int lHashVal, short wFlags, out ITypeInfo ppTInfo, out DESCKIND pDescKind, out BINDPTR pBindPtr);
+ void BindType([MarshalAs(UnmanagedType.LPWStr)] string szName, int lHashVal, out ITypeInfo ppTInfo, out ITypeComp ppTComp);
}
}
// Actual fields of the TypeAttr struct.
public Guid guid;
- public Int32 lcid;
- public Int32 dwReserved;
- public Int32 memidConstructor;
- public Int32 memidDestructor;
+ public int lcid;
+ public int dwReserved;
+ public int memidConstructor;
+ public int memidDestructor;
public IntPtr lpstrSchema;
- public Int32 cbSizeInstance;
+ public int cbSizeInstance;
public TYPEKIND typekind;
- public Int16 cFuncs;
- public Int16 cVars;
- public Int16 cImplTypes;
- public Int16 cbSizeVft;
- public Int16 cbAlignment;
+ public short cFuncs;
+ public short cVars;
+ public short cImplTypes;
+ public short cbSizeVft;
+ public short cbAlignment;
public TYPEFLAGS wTypeFlags;
- public Int16 wMajorVerNum;
- public Int16 wMinorVerNum;
+ public short wMajorVerNum;
+ public short wMinorVerNum;
public TYPEDESC tdescAlias;
public IDLDESC idldescType;
}
public FUNCKIND funckind; //FUNCKIND funckind;
public INVOKEKIND invkind; //INVOKEKIND invkind;
public CALLCONV callconv; //CALLCONV callconv;
- public Int16 cParams; //short cParams;
- public Int16 cParamsOpt; //short cParamsOpt;
- public Int16 oVft; //short oVft;
- public Int16 cScodes; //short cScodes;
+ public short cParams; //short cParams;
+ public short cParamsOpt; //short cParamsOpt;
+ public short oVft; //short oVft;
+ public short cScodes; //short cScodes;
public ELEMDESC elemdescFunc; //ELEMDESC elemdescFunc;
- public Int16 wFuncFlags; //WORD wFuncFlags;
+ public short wFuncFlags; //WORD wFuncFlags;
}
[Flags()]
public struct TYPEDESC
{
public IntPtr lpValue;
- public Int16 vt;
+ public short vt;
}
[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct VARDESC
{
public int memid;
- public String lpstrSchema;
+ public string lpstrSchema;
[System.Runtime.InteropServices.StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)]
public struct EXCEPINFO
{
- public Int16 wCode;
- public Int16 wReserved;
- [MarshalAs(UnmanagedType.BStr)] public String bstrSource;
- [MarshalAs(UnmanagedType.BStr)] public String bstrDescription;
- [MarshalAs(UnmanagedType.BStr)] public String bstrHelpFile;
+ public short wCode;
+ public short wReserved;
+ [MarshalAs(UnmanagedType.BStr)] public string bstrSource;
+ [MarshalAs(UnmanagedType.BStr)] public string bstrDescription;
+ [MarshalAs(UnmanagedType.BStr)] public string bstrHelpFile;
public int dwHelpContext;
public IntPtr pvReserved;
public IntPtr pfnDeferredFillIn;
- public Int32 scode;
+ public int scode;
}
public enum FUNCKIND : int
void GetTypeComp(out ITypeComp ppTComp);
void GetFuncDesc(int index, out IntPtr ppFuncDesc);
void GetVarDesc(int index, out IntPtr ppVarDesc);
- void GetNames(int memid, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2), Out] String[] rgBstrNames, int cMaxNames, out int pcNames);
+ void GetNames(int memid, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2), Out] string[] rgBstrNames, int cMaxNames, out int pcNames);
void GetRefTypeOfImplType(int index, out int href);
void GetImplTypeFlags(int index, out IMPLTYPEFLAGS pImplTypeFlags);
- void GetIDsOfNames([MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr, SizeParamIndex = 1), In] String[] rgszNames, int cNames, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1), Out] int[] pMemId);
- void Invoke([MarshalAs(UnmanagedType.IUnknown)] Object pvInstance, int memid, Int16 wFlags, ref DISPPARAMS pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, out int puArgErr);
- void GetDocumentation(int index, out String strName, out String strDocString, out int dwHelpContext, out String strHelpFile);
+ void GetIDsOfNames([MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr, SizeParamIndex = 1), In] string[] rgszNames, int cNames, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1), Out] int[] pMemId);
+ void Invoke([MarshalAs(UnmanagedType.IUnknown)] object pvInstance, int memid, short wFlags, ref DISPPARAMS pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, out int puArgErr);
+ void GetDocumentation(int index, out string strName, out string strDocString, out int dwHelpContext, out string strHelpFile);
void GetDllEntry(int memid, INVOKEKIND invKind, IntPtr pBstrDllName, IntPtr pBstrName, IntPtr pwOrdinal);
void GetRefTypeInfo(int hRef, out ITypeInfo ppTI);
void AddressOfMember(int memid, INVOKEKIND invKind, out IntPtr ppv);
- void CreateInstance([MarshalAs(UnmanagedType.IUnknown)] Object pUnkOuter, [In] ref Guid riid, [MarshalAs(UnmanagedType.IUnknown), Out] out Object ppvObj);
- void GetMops(int memid, out String pBstrMops);
+ void CreateInstance([MarshalAs(UnmanagedType.IUnknown)] object pUnkOuter, [In] ref Guid riid, [MarshalAs(UnmanagedType.IUnknown), Out] out object ppvObj);
+ void GetMops(int memid, out string pBstrMops);
void GetContainingTypeLib(out ITypeLib ppTLB, out int pIndex);
[PreserveSig]
void ReleaseTypeAttr(IntPtr pTypeAttr);
new void GetTypeComp(out ITypeComp ppTComp);
new void GetFuncDesc(int index, out IntPtr ppFuncDesc);
new void GetVarDesc(int index, out IntPtr ppVarDesc);
- new void GetNames(int memid, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2), Out] String[] rgBstrNames, int cMaxNames, out int pcNames);
+ new void GetNames(int memid, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2), Out] string[] rgBstrNames, int cMaxNames, out int pcNames);
new void GetRefTypeOfImplType(int index, out int href);
new void GetImplTypeFlags(int index, out IMPLTYPEFLAGS pImplTypeFlags);
- new void GetIDsOfNames([MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr, SizeParamIndex = 1), In] String[] rgszNames, int cNames, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1), Out] int[] pMemId);
- new void Invoke([MarshalAs(UnmanagedType.IUnknown)] Object pvInstance, int memid, Int16 wFlags, ref DISPPARAMS pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, out int puArgErr);
- new void GetDocumentation(int index, out String strName, out String strDocString, out int dwHelpContext, out String strHelpFile);
+ new void GetIDsOfNames([MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPWStr, SizeParamIndex = 1), In] string[] rgszNames, int cNames, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1), Out] int[] pMemId);
+ new void Invoke([MarshalAs(UnmanagedType.IUnknown)] object pvInstance, int memid, short wFlags, ref DISPPARAMS pDispParams, IntPtr pVarResult, IntPtr pExcepInfo, out int puArgErr);
+ new void GetDocumentation(int index, out string strName, out string strDocString, out int dwHelpContext, out string strHelpFile);
new void GetDllEntry(int memid, INVOKEKIND invKind, IntPtr pBstrDllName, IntPtr pBstrName, IntPtr pwOrdinal);
new void GetRefTypeInfo(int hRef, out ITypeInfo ppTI);
new void AddressOfMember(int memid, INVOKEKIND invKind, out IntPtr ppv);
- new void CreateInstance([MarshalAs(UnmanagedType.IUnknown)] Object pUnkOuter, [In] ref Guid riid, [MarshalAs(UnmanagedType.IUnknown), Out] out Object ppvObj);
- new void GetMops(int memid, out String pBstrMops);
+ new void CreateInstance([MarshalAs(UnmanagedType.IUnknown)] object pUnkOuter, [In] ref Guid riid, [MarshalAs(UnmanagedType.IUnknown), Out] out object ppvObj);
+ new void GetMops(int memid, out string pBstrMops);
new void GetContainingTypeLib(out ITypeLib ppTLB, out int pIndex);
[PreserveSig]
new void ReleaseTypeAttr(IntPtr pTypeAttr);
void GetTypeFlags(out int pTypeFlags);
void GetFuncIndexOfMemId(int memid, INVOKEKIND invKind, out int pFuncIndex);
void GetVarIndexOfMemId(int memid, out int pVarIndex);
- void GetCustData(ref Guid guid, out Object pVarVal);
- void GetFuncCustData(int index, ref Guid guid, out Object pVarVal);
- void GetParamCustData(int indexFunc, int indexParam, ref Guid guid, out Object pVarVal);
- void GetVarCustData(int index, ref Guid guid, out Object pVarVal);
- void GetImplTypeCustData(int index, ref Guid guid, out Object pVarVal);
+ void GetCustData(ref Guid guid, out object pVarVal);
+ void GetFuncCustData(int index, ref Guid guid, out object pVarVal);
+ void GetParamCustData(int indexFunc, int indexParam, ref Guid guid, out object pVarVal);
+ void GetVarCustData(int index, ref Guid guid, out object pVarVal);
+ void GetImplTypeCustData(int index, ref Guid guid, out object pVarVal);
[LCIDConversionAttribute(1)]
- void GetDocumentation2(int memid, out String pbstrHelpString, out int pdwHelpStringContext, out String pbstrHelpStringDll);
+ void GetDocumentation2(int memid, out string pbstrHelpString, out int pdwHelpStringContext, out string pbstrHelpStringDll);
void GetAllCustData(IntPtr pCustData);
void GetAllFuncCustData(int index, IntPtr pCustData);
void GetAllParamCustData(int indexFunc, int indexParam, IntPtr pCustData);
public Guid guid;
public int lcid;
public SYSKIND syskind;
- public Int16 wMajorVerNum;
- public Int16 wMinorVerNum;
+ public short wMajorVerNum;
+ public short wMinorVerNum;
public LIBFLAGS wLibFlags;
}
void GetTypeInfoOfGuid(ref Guid guid, out ITypeInfo ppTInfo);
void GetLibAttr(out IntPtr ppTLibAttr);
void GetTypeComp(out ITypeComp ppTComp);
- void GetDocumentation(int index, out String strName, out String strDocString, out int dwHelpContext, out String strHelpFile);
+ void GetDocumentation(int index, out string strName, out string strDocString, out int dwHelpContext, out string strHelpFile);
[return: MarshalAs(UnmanagedType.Bool)]
- bool IsName([MarshalAs(UnmanagedType.LPWStr)] String szNameBuf, int lHashVal);
- void FindName([MarshalAs(UnmanagedType.LPWStr)] String szNameBuf, int lHashVal, [MarshalAs(UnmanagedType.LPArray), Out] ITypeInfo[] ppTInfo, [MarshalAs(UnmanagedType.LPArray), Out] int[] rgMemId, ref Int16 pcFound);
+ bool IsName([MarshalAs(UnmanagedType.LPWStr)] string szNameBuf, int lHashVal);
+ void FindName([MarshalAs(UnmanagedType.LPWStr)] string szNameBuf, int lHashVal, [MarshalAs(UnmanagedType.LPArray), Out] ITypeInfo[] ppTInfo, [MarshalAs(UnmanagedType.LPArray), Out] int[] rgMemId, ref short pcFound);
[PreserveSig]
void ReleaseTLibAttr(IntPtr pTLibAttr);
}
new void GetTypeInfoOfGuid(ref Guid guid, out ITypeInfo ppTInfo);
new void GetLibAttr(out IntPtr ppTLibAttr);
new void GetTypeComp(out ITypeComp ppTComp);
- new void GetDocumentation(int index, out String strName, out String strDocString, out int dwHelpContext, out String strHelpFile);
+ new void GetDocumentation(int index, out string strName, out string strDocString, out int dwHelpContext, out string strHelpFile);
[return: MarshalAs(UnmanagedType.Bool)]
- new bool IsName([MarshalAs(UnmanagedType.LPWStr)] String szNameBuf, int lHashVal);
- new void FindName([MarshalAs(UnmanagedType.LPWStr)] String szNameBuf, int lHashVal, [MarshalAs(UnmanagedType.LPArray), Out] ITypeInfo[] ppTInfo, [MarshalAs(UnmanagedType.LPArray), Out] int[] rgMemId, ref Int16 pcFound);
+ new bool IsName([MarshalAs(UnmanagedType.LPWStr)] string szNameBuf, int lHashVal);
+ new void FindName([MarshalAs(UnmanagedType.LPWStr)] string szNameBuf, int lHashVal, [MarshalAs(UnmanagedType.LPArray), Out] ITypeInfo[] ppTInfo, [MarshalAs(UnmanagedType.LPArray), Out] int[] rgMemId, ref short pcFound);
[PreserveSig]
new void ReleaseTLibAttr(IntPtr pTLibAttr);
- void GetCustData(ref Guid guid, out Object pVarVal);
+ void GetCustData(ref Guid guid, out object pVarVal);
[LCIDConversionAttribute(1)]
- void GetDocumentation2(int index, out String pbstrHelpString, out int pdwHelpStringContext, out String pbstrHelpStringDll);
+ void GetDocumentation2(int index, out string pbstrHelpString, out int pdwHelpStringContext, out string pbstrHelpStringDll);
void GetLibStatistics(IntPtr pcUniqueNames, out int pcchUniqueNames);
void GetAllCustData(IntPtr pCustData);
}
{
public sealed class CurrencyWrapper
{
- public CurrencyWrapper(Decimal obj)
+ public CurrencyWrapper(decimal obj)
{
m_WrappedObject = obj;
}
- public CurrencyWrapper(Object obj)
+ public CurrencyWrapper(object obj)
{
- if (!(obj is Decimal))
+ if (!(obj is decimal))
throw new ArgumentException(SR.Arg_MustBeDecimal, nameof(obj));
- m_WrappedObject = (Decimal)obj;
+ m_WrappedObject = (decimal)obj;
}
- public Decimal WrappedObject
+ public decimal WrappedObject
{
get
{
}
}
- private Decimal m_WrappedObject;
+ private decimal m_WrappedObject;
}
}
{
public sealed class DispatchWrapper
{
- public DispatchWrapper(Object obj)
+ public DispatchWrapper(object obj)
{
if (obj != null)
{
m_WrappedObject = obj;
}
- public Object WrappedObject
+ public object WrappedObject
{
get
{
}
}
- private Object m_WrappedObject;
+ private object m_WrappedObject;
}
}
m_ErrorCode = errorCode;
}
- public ErrorWrapper(Object errorCode)
+ public ErrorWrapper(object errorCode)
{
if (!(errorCode is int))
throw new ArgumentException(SR.Arg_MustBeInt32, nameof(errorCode));
{
// Add a new Field to the reflection object. The field has
// name as its name.
- FieldInfo AddField(String name);
+ FieldInfo AddField(string name);
// Removes the specified member.
void RemoveMember(MemberInfo m);
#endif
// Allocate a handle storing the object and the type.
- internal GCHandle(Object value, GCHandleType type)
+ internal GCHandle(object value, GCHandleType type)
{
// Make sure the type parameter is within the valid range for the enum.
if ((uint)type > (uint)MaxHandleType)
// type - The type of GC handle to create.
//
// returns a new GC handle that protects the object.
- public static GCHandle Alloc(Object value)
+ public static GCHandle Alloc(object value)
{
return new GCHandle(value, GCHandleType.Normal);
}
- public static GCHandle Alloc(Object value, GCHandleType type)
+ public static GCHandle Alloc(object value, GCHandleType type)
{
return new GCHandle(value, type);
}
}
// Target property - allows getting / updating of the handle's referent.
- public Object Target
+ public object Target
{
get
{
return m_handle.GetHashCode();
}
- public override bool Equals(Object o)
+ public override bool Equals(object o)
{
GCHandle hnd;
// Internal native calls that this implementation uses.
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern IntPtr InternalAlloc(Object value, GCHandleType type);
+ internal static extern IntPtr InternalAlloc(object value, GCHandleType type);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern void InternalFree(IntPtr handle);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern Object InternalGet(IntPtr handle);
+ internal static extern object InternalGet(IntPtr handle);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern void InternalSet(IntPtr handle, Object value, bool isPinned);
+ internal static extern void InternalSet(IntPtr handle, object value, bool isPinned);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern Object InternalCompareExchange(IntPtr handle, Object value, Object oldValue, bool isPinned);
+ internal static extern object InternalCompareExchange(IntPtr handle, object value, object oldValue, bool isPinned);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern IntPtr InternalAddrOfPinnedObject(IntPtr handle);
{
public interface ICustomAdapter
{
- [return: MarshalAs(UnmanagedType.IUnknown)] Object GetUnderlyingObject();
+ [return: MarshalAs(UnmanagedType.IUnknown)] object GetUnderlyingObject();
}
}
{
public interface ICustomMarshaler
{
- Object MarshalNativeToManaged(IntPtr pNativeData);
+ object MarshalNativeToManaged(IntPtr pNativeData);
- IntPtr MarshalManagedToNative(Object ManagedObj);
+ IntPtr MarshalManagedToNative(object ManagedObj);
void CleanUpNativeData(IntPtr pNativeData);
- void CleanUpManagedData(Object ManagedObj);
+ void CleanUpManagedData(object ManagedObj);
int GetNativeDataSize();
}
HResult = HResults.COR_E_INVALIDCOMOBJECT;
}
- public InvalidComObjectException(String message)
+ public InvalidComObjectException(string message)
: base(message)
{
HResult = HResults.COR_E_INVALIDCOMOBJECT;
}
- public InvalidComObjectException(String message, Exception inner)
+ public InvalidComObjectException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_INVALIDCOMOBJECT;
HResult = HResults.COR_E_INVALIDOLEVARIANTTYPE;
}
- public InvalidOleVariantTypeException(String message)
+ public InvalidOleVariantTypeException(string message)
: base(message)
{
HResult = HResults.COR_E_INVALIDOLEVARIANTTYPE;
}
- public InvalidOleVariantTypeException(String message, Exception inner)
+ public InvalidOleVariantTypeException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_INVALIDOLEVARIANTTYPE;
//====================================================================
// SizeOf()
//====================================================================
- public static int SizeOf(Object structure)
+ public static int SizeOf(object structure)
{
if (structure == null)
throw new ArgumentNullException(nameof(structure));
CopyToNative(source, startIndex, destination, length);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void CopyToNative(Object source, int startIndex, IntPtr destination, int length);
+ private static extern void CopyToNative(object source, int startIndex, IntPtr destination, int length);
//====================================================================
// Copy blocks from native memory to CLR arrays
CopyToManaged(source, destination, startIndex, length);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void CopyToManaged(IntPtr source, Object destination, int startIndex, int length);
+ private static extern void CopyToManaged(IntPtr source, object destination, int startIndex, int length);
//====================================================================
// Read from memory
//====================================================================
- public static byte ReadByte(Object ptr, int ofs)
+ public static byte ReadByte(object ptr, int ofs)
{
return ReadValueSlow(ptr, ofs, (IntPtr nativeHome, int offset) => Marshal.ReadByte(nativeHome, offset));
}
return ReadByte(ptr, 0);
}
- public static short ReadInt16(Object ptr, int ofs)
+ public static short ReadInt16(object ptr, int ofs)
{
return ReadValueSlow(ptr, ofs, (IntPtr nativeHome, int offset) => Marshal.ReadInt16(nativeHome, offset));
}
return ReadInt32(ptr, 0);
}
- public static IntPtr ReadIntPtr(Object ptr, int ofs)
+ public static IntPtr ReadIntPtr(object ptr, int ofs)
{
#if BIT64
return (IntPtr)ReadInt64(ptr, ofs);
#endif
}
- public static long ReadInt64([MarshalAs(UnmanagedType.AsAny), In] Object ptr, int ofs)
+ public static long ReadInt64([MarshalAs(UnmanagedType.AsAny), In] object ptr, int ofs)
{
return ReadValueSlow(ptr, ofs, (IntPtr nativeHome, int offset) => Marshal.ReadInt64(nativeHome, offset));
}
}
}
- public static void WriteByte(Object ptr, int ofs, byte val)
+ public static void WriteByte(object ptr, int ofs, byte val)
{
WriteValueSlow(ptr, ofs, val, (IntPtr nativeHome, int offset, byte value) => Marshal.WriteByte(nativeHome, offset, value));
}
}
}
- public static void WriteInt16(Object ptr, int ofs, short val)
+ public static void WriteInt16(object ptr, int ofs, short val)
{
WriteValueSlow(ptr, ofs, val, (IntPtr nativeHome, int offset, short value) => Marshal.WriteInt16(nativeHome, offset, value));
}
WriteInt16(ptr, ofs, (short)val);
}
- public static void WriteInt16([In, Out]Object ptr, int ofs, char val)
+ public static void WriteInt16([In, Out]object ptr, int ofs, char val)
{
WriteInt16(ptr, ofs, (short)val);
}
}
}
- public static void WriteInt32(Object ptr, int ofs, int val)
+ public static void WriteInt32(object ptr, int ofs, int val)
{
WriteValueSlow(ptr, ofs, val, (IntPtr nativeHome, int offset, int value) => Marshal.WriteInt32(nativeHome, offset, value));
}
#endif
}
- public static void WriteIntPtr(Object ptr, int ofs, IntPtr val)
+ public static void WriteIntPtr(object ptr, int ofs, IntPtr val)
{
#if BIT64
WriteInt64(ptr, ofs, (long)val);
}
}
- public static void WriteInt64(Object ptr, int ofs, long val)
+ public static void WriteInt64(object ptr, int ofs, long val)
{
WriteValueSlow(ptr, ofs, val, (IntPtr nativeHome, int offset, long value) => Marshal.WriteInt64(nativeHome, offset, value));
}
// "fDeleteOld" is true, this routine will call DestroyStructure() first.
//====================================================================
[MethodImplAttribute(MethodImplOptions.InternalCall), ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
- public static extern void StructureToPtr(Object structure, IntPtr ptr, bool fDeleteOld);
+ public static extern void StructureToPtr(object structure, IntPtr ptr, bool fDeleteOld);
public static void StructureToPtr<T>(T structure, IntPtr ptr, bool fDeleteOld)
{
//====================================================================
// Marshals data from a native memory block to a preallocated structure class.
//====================================================================
- public static void PtrToStructure(IntPtr ptr, Object structure)
+ public static void PtrToStructure(IntPtr ptr, object structure)
{
PtrToStructureHelper(ptr, structure, false);
}
// Creates a new instance of "structuretype" and marshals data from a
// native memory block to it.
//====================================================================
- public static Object PtrToStructure(IntPtr ptr, Type structureType)
+ public static object PtrToStructure(IntPtr ptr, Type structureType)
{
if (ptr == IntPtr.Zero) return null;
if (rt == null)
throw new ArgumentException(SR.Arg_MustBeType, nameof(structureType));
- Object structure = rt.CreateInstanceDefaultCtor(false /*publicOnly*/, false /*skipCheckThis*/, false /*fillCache*/, true /*wrapExceptions*/);
+ object structure = rt.CreateInstanceDefaultCtor(false /*publicOnly*/, false /*skipCheckThis*/, false /*fillCache*/, true /*wrapExceptions*/);
PtrToStructureHelper(ptr, structure, true);
return structure;
}
// Helper function to copy a pointer into a preallocated structure.
//====================================================================
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void PtrToStructureHelper(IntPtr ptr, Object structure, bool allowValueClasses);
+ private static extern void PtrToStructureHelper(IntPtr ptr, object structure, bool allowValueClasses);
//====================================================================
public static IntPtr AllocHGlobal(IntPtr cb)
{
// For backwards compatibility on 32 bit platforms, ensure we pass values between
- // Int32.MaxValue and UInt32.MaxValue to Windows. If the binary has had the
+ // int.MaxValue and uint.MaxValue to Windows. If the binary has had the
// LARGEADDRESSAWARE bit set in the PE header, it may get 3 or 4 GB of user mode
// address space. It is remotely that those allocations could have succeeded,
// though I couldn't reproduce that. In either case, that means we should continue
// is the one where the RCW was first seen. Will return null
// otherwise.
//====================================================================
- public static IntPtr /* IUnknown* */ GetIUnknownForObject(Object o)
+ public static IntPtr /* IUnknown* */ GetIUnknownForObject(object o)
{
return GetIUnknownForObjectNative(o, false);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern IntPtr /* IUnknown* */ GetIUnknownForObjectNative(Object o, bool onlyInContext);
+ private static extern IntPtr /* IUnknown* */ GetIUnknownForObjectNative(object o, bool onlyInContext);
//====================================================================
// return the raw IUnknown* for a COM Object not related to current
// Does not call AddRef
//====================================================================
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern IntPtr /* IUnknown* */ GetRawIUnknownForComObjectNoAddRef(Object o);
+ internal static extern IntPtr /* IUnknown* */ GetRawIUnknownForComObjectNoAddRef(object o);
#endif // FEATURE_COMINTEROP
//====================================================================
// return the IDispatch* for an Object
//====================================================================
- public static IntPtr /* IDispatch */ GetIDispatchForObject(Object o)
+ public static IntPtr /* IDispatch */ GetIDispatchForObject(object o)
{
throw new PlatformNotSupportedException();
}
// return the IUnknown* representing the interface for the Object
// Object o should support Type T
//====================================================================
- public static IntPtr /* IUnknown* */ GetComInterfaceForObject(Object o, Type T)
+ public static IntPtr /* IUnknown* */ GetComInterfaceForObject(object o, Type T)
{
return GetComInterfaceForObjectNative(o, T, false, true);
}
// Object o should support Type T, it refer the value of mode to
// invoke customized QueryInterface or not
//====================================================================
- public static IntPtr /* IUnknown* */ GetComInterfaceForObject(Object o, Type T, CustomQueryInterfaceMode mode)
+ public static IntPtr /* IUnknown* */ GetComInterfaceForObject(object o, Type T, CustomQueryInterfaceMode mode)
{
bool bEnableCustomizedQueryInterface = ((mode == CustomQueryInterfaceMode.Allow) ? true : false);
return GetComInterfaceForObjectNative(o, T, false, bEnableCustomizedQueryInterface);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern IntPtr /* IUnknown* */ GetComInterfaceForObjectNative(Object o, Type t, bool onlyInContext, bool fEnalbeCustomizedQueryInterface);
+ private static extern IntPtr /* IUnknown* */ GetComInterfaceForObjectNative(object o, Type t, bool onlyInContext, bool fEnalbeCustomizedQueryInterface);
//====================================================================
// return an Object for IUnknown
//====================================================================
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern Object GetObjectForIUnknown(IntPtr /* IUnknown* */ pUnk);
+ public static extern object GetObjectForIUnknown(IntPtr /* IUnknown* */ pUnk);
//====================================================================
// Return a unique Object given an IUnknown. This ensures that you
// and not worry about other active uses of said RCW.
//====================================================================
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern Object GetUniqueObjectForIUnknown(IntPtr unknown);
+ public static extern object GetUniqueObjectForIUnknown(IntPtr unknown);
//====================================================================
// return an Object for IUnknown, using the Type T,
// imported Type
//====================================================================
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern Object GetTypedObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, Type t);
+ public static extern object GetTypedObjectForIUnknown(IntPtr /* IUnknown* */ pUnk, Type t);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern IntPtr CreateAggregatedObject(IntPtr pOuter, Object o);
+ public static extern IntPtr CreateAggregatedObject(IntPtr pOuter, object o);
public static IntPtr CreateAggregatedObject<T>(IntPtr pOuter, T o)
{
// check if the object is classic COM component
//====================================================================
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern bool IsComObject(Object o);
+ public static extern bool IsComObject(object o);
#endif // FEATURE_COMINTEROP
// release the COM component and if the reference hits 0 zombie this object
// further usage of this Object might throw an exception
//====================================================================
- public static int ReleaseComObject(Object o)
+ public static int ReleaseComObject(object o)
{
__ComObject co = null;
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern int InternalReleaseComObject(Object o);
+ internal static extern int InternalReleaseComObject(object o);
//====================================================================
// release the COM component and zombie this object
// further usage of this Object might throw an exception
//====================================================================
- public static Int32 FinalReleaseComObject(Object o)
+ public static int FinalReleaseComObject(object o)
{
if (o == null)
throw new ArgumentNullException(nameof(o));
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern void InternalFinalReleaseComObject(Object o);
+ internal static extern void InternalFinalReleaseComObject(object o);
#endif // FEATURE_COMINTEROP
//====================================================================
// This method retrieves data from the COM object.
//====================================================================
- public static Object GetComObjectData(Object obj, Object key)
+ public static object GetComObjectData(object obj, object key)
{
throw new PlatformNotSupportedException(SR.Arg_PlatformNotSupported);
}
// true if the data has been added, false if the data could not be
// added because there already was data for the specified key.
//====================================================================
- public static bool SetComObjectData(Object obj, Object key, Object data)
+ public static bool SetComObjectData(object obj, object key, object data)
{
throw new PlatformNotSupportedException(SR.Arg_PlatformNotSupported);
}
// This method takes the given COM object and wraps it in an object
// of the specified type. The type must be derived from __ComObject.
//====================================================================
- public static Object CreateWrapperOfType(Object o, Type t)
+ public static object CreateWrapperOfType(object o, Type t)
{
// Validate the arguments.
if (t == null)
return o;
// Check to see if we already have a cached wrapper for this type.
- Object Wrapper = GetComObjectData(o, t);
+ object Wrapper = GetComObjectData(o, t);
if (Wrapper == null)
{
// Create the wrapper for the specified type.
// Helper method called from CreateWrapperOfType.
//====================================================================
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern Object InternalCreateWrapperOfType(Object o, Type t);
+ private static extern object InternalCreateWrapperOfType(object o, Type t);
//====================================================================
// IUnknown Helpers
public static extern int /* ULONG */ Release(IntPtr /* IUnknown */ pUnk);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern void GetNativeVariantForObject(Object obj, /* VARIANT * */ IntPtr pDstNativeVariant);
+ public static extern void GetNativeVariantForObject(object obj, /* VARIANT * */ IntPtr pDstNativeVariant);
public static void GetNativeVariantForObject<T>(T obj, IntPtr pDstNativeVariant)
{
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern Object GetObjectForNativeVariant(/* VARIANT * */ IntPtr pSrcNativeVariant);
+ public static extern object GetObjectForNativeVariant(/* VARIANT * */ IntPtr pSrcNativeVariant);
public static T GetObjectForNativeVariant<T>(IntPtr pSrcNativeVariant)
{
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern Object[] GetObjectsForNativeVariants(/* VARIANT * */ IntPtr aSrcNativeVariant, int cVars);
+ public static extern object[] GetObjectsForNativeVariants(/* VARIANT * */ IntPtr aSrcNativeVariant, int cVars);
public static T[] GetObjectsForNativeVariants<T>(IntPtr aSrcNativeVariant, int cVars)
{
//====================================================================
// This method binds to the specified moniker.
//====================================================================
- public static Object BindToMoniker(string monikerName)
+ public static object BindToMoniker(string monikerName)
{
- Object obj = null;
+ object obj = null;
IBindCtx bindctx = null;
CreateBindCtx(0, out bindctx);
- UInt32 cbEaten;
+ uint cbEaten;
IMoniker pmoniker = null;
MkParseDisplayName(bindctx, monikerName, out cbEaten, out pmoniker);
}
[DllImport(Interop.Libraries.Ole32, PreserveSig = false)]
- private static extern void CreateBindCtx(UInt32 reserved, out IBindCtx ppbc);
+ private static extern void CreateBindCtx(uint reserved, out IBindCtx ppbc);
[DllImport(Interop.Libraries.Ole32, PreserveSig = false)]
- private static extern void MkParseDisplayName(IBindCtx pbc, [MarshalAs(UnmanagedType.LPWStr)] string szUserName, out UInt32 pchEaten, out IMoniker ppmk);
+ private static extern void MkParseDisplayName(IBindCtx pbc, [MarshalAs(UnmanagedType.LPWStr)] string szUserName, out uint pchEaten, out IMoniker ppmk);
[DllImport(Interop.Libraries.Ole32, PreserveSig = false)]
- private static extern void BindMoniker(IMoniker pmk, UInt32 grfOpt, ref Guid iidResult, [MarshalAs(UnmanagedType.Interface)] out Object ppvResult);
+ private static extern void BindMoniker(IMoniker pmk, uint grfOpt, ref Guid iidResult, [MarshalAs(UnmanagedType.Interface)] out object ppvResult);
//========================================================================
// Private method called from EE upon use of license/ICF2 marshaling.
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern void ChangeWrapperHandleStrength(Object otp, bool fIsWeak);
+ public static extern void ChangeWrapperHandleStrength(object otp, bool fIsWeak);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern void InitializeWrapperForWinRT(object o, ref IntPtr pUnk);
internal static class RuntimeEnvironment
{
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern String GetModuleFileName();
+ internal static extern string GetModuleFileName();
- public static String GetSystemVersion()
+ public static string GetSystemVersion()
{
return Assembly.GetExecutingAssembly().ImageRuntimeVersion;
}
HResult = HResults.E_FAIL;
}
- public SEHException(String message)
+ public SEHException(string message)
: base(message)
{
HResult = HResults.E_FAIL;
}
- public SEHException(String message, Exception inner)
+ public SEHException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.E_FAIL;
HResult = HResults.COR_E_SAFEARRAYRANKMISMATCH;
}
- public SafeArrayRankMismatchException(String message)
+ public SafeArrayRankMismatchException(string message)
: base(message)
{
HResult = HResults.COR_E_SAFEARRAYRANKMISMATCH;
}
- public SafeArrayRankMismatchException(String message, Exception inner)
+ public SafeArrayRankMismatchException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_SAFEARRAYRANKMISMATCH;
HResult = HResults.COR_E_SAFEARRAYTYPEMISMATCH;
}
- public SafeArrayTypeMismatchException(String message)
+ public SafeArrayTypeMismatchException(string message)
: base(message)
{
HResult = HResults.COR_E_SAFEARRAYTYPEMISMATCH;
}
- public SafeArrayTypeMismatchException(String message, Exception inner)
+ public SafeArrayTypeMismatchException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_SAFEARRAYTYPEMISMATCH;
{
public sealed class UnknownWrapper
{
- public UnknownWrapper(Object obj)
+ public UnknownWrapper(object obj)
{
m_WrappedObject = obj;
}
- public Object WrappedObject
+ public object WrappedObject
{
get
{
}
}
- private Object m_WrappedObject;
+ private object m_WrappedObject;
}
}
{
public sealed class VariantWrapper
{
- public VariantWrapper(Object obj)
+ public VariantWrapper(object obj)
{
m_WrappedObject = obj;
}
- public Object WrappedObject
+ public object WrappedObject
{
get
{
}
}
- private Object m_WrappedObject;
+ private object m_WrappedObject;
}
}
{
IBindableVector _this = Unsafe.As<IBindableVector>(this);
uint size = _this.Size;
- if (((uint)Int32.MaxValue) < size)
+ if (((uint)int.MaxValue) < size)
{
throw new InvalidOperationException(SR.InvalidOperation_CollectionBackingListTooLarge);
}
_this.Append(value);
uint size = _this.Size;
- if (((uint)Int32.MaxValue) < size)
+ if (((uint)int.MaxValue) < size)
{
throw new InvalidOperationException(SR.InvalidOperation_CollectionBackingListTooLarge);
}
if (!exists)
return -1;
- if (((uint)Int32.MaxValue) < index)
+ if (((uint)int.MaxValue) < index)
{
throw new InvalidOperationException(SR.InvalidOperation_CollectionBackingListTooLarge);
}
if (exists)
{
- if (((uint)Int32.MaxValue) < index)
+ if (((uint)int.MaxValue) < index)
{
throw new InvalidOperationException(SR.InvalidOperation_CollectionBackingListTooLarge);
}
internal class CLRIPropertyValueImpl : IPropertyValue
{
private PropertyType _type;
- private Object _data;
+ private object _data;
// Numeric scalar types which participate in coersion
private static volatile Tuple<Type, PropertyType>[] s_numericScalarTypes;
- internal CLRIPropertyValueImpl(PropertyType type, Object data)
+ internal CLRIPropertyValueImpl(PropertyType type, object data)
{
_type = type;
_data = data;
if (s_numericScalarTypes == null)
{
Tuple<Type, PropertyType>[] numericScalarTypes = new Tuple<Type, PropertyType>[] {
- new Tuple<Type, PropertyType>(typeof(Byte), PropertyType.UInt8),
- new Tuple<Type, PropertyType>(typeof(Int16), PropertyType.Int16),
- new Tuple<Type, PropertyType>(typeof(UInt16), PropertyType.UInt16),
- new Tuple<Type, PropertyType>(typeof(Int32), PropertyType.Int32),
- new Tuple<Type, PropertyType>(typeof(UInt32), PropertyType.UInt32),
- new Tuple<Type, PropertyType>(typeof(Int64), PropertyType.Int64),
- new Tuple<Type, PropertyType>(typeof(UInt64), PropertyType.UInt64),
- new Tuple<Type, PropertyType>(typeof(Single), PropertyType.Single),
- new Tuple<Type, PropertyType>(typeof(Double), PropertyType.Double)
+ new Tuple<Type, PropertyType>(typeof(byte), PropertyType.UInt8),
+ new Tuple<Type, PropertyType>(typeof(short), PropertyType.Int16),
+ new Tuple<Type, PropertyType>(typeof(ushort), PropertyType.UInt16),
+ new Tuple<Type, PropertyType>(typeof(int), PropertyType.Int32),
+ new Tuple<Type, PropertyType>(typeof(uint), PropertyType.UInt32),
+ new Tuple<Type, PropertyType>(typeof(long), PropertyType.Int64),
+ new Tuple<Type, PropertyType>(typeof(ulong), PropertyType.UInt64),
+ new Tuple<Type, PropertyType>(typeof(float), PropertyType.Single),
+ new Tuple<Type, PropertyType>(typeof(double), PropertyType.Double)
};
s_numericScalarTypes = numericScalarTypes;
}
}
- public Byte GetUInt8()
+ public byte GetUInt8()
{
- return CoerceScalarValue<Byte>(PropertyType.UInt8);
+ return CoerceScalarValue<byte>(PropertyType.UInt8);
}
- public Int16 GetInt16()
+ public short GetInt16()
{
- return CoerceScalarValue<Int16>(PropertyType.Int16);
+ return CoerceScalarValue<short>(PropertyType.Int16);
}
- public UInt16 GetUInt16()
+ public ushort GetUInt16()
{
- return CoerceScalarValue<UInt16>(PropertyType.UInt16);
+ return CoerceScalarValue<ushort>(PropertyType.UInt16);
}
- public Int32 GetInt32()
+ public int GetInt32()
{
- return CoerceScalarValue<Int32>(PropertyType.Int32);
+ return CoerceScalarValue<int>(PropertyType.Int32);
}
- public UInt32 GetUInt32()
+ public uint GetUInt32()
{
- return CoerceScalarValue<UInt32>(PropertyType.UInt32);
+ return CoerceScalarValue<uint>(PropertyType.UInt32);
}
- public Int64 GetInt64()
+ public long GetInt64()
{
- return CoerceScalarValue<Int64>(PropertyType.Int64);
+ return CoerceScalarValue<long>(PropertyType.Int64);
}
- public UInt64 GetUInt64()
+ public ulong GetUInt64()
{
- return CoerceScalarValue<UInt64>(PropertyType.UInt64);
+ return CoerceScalarValue<ulong>(PropertyType.UInt64);
}
- public Single GetSingle()
+ public float GetSingle()
{
- return CoerceScalarValue<Single>(PropertyType.Single);
+ return CoerceScalarValue<float>(PropertyType.Single);
}
- public Double GetDouble()
+ public double GetDouble()
{
- return CoerceScalarValue<Double>(PropertyType.Double);
+ return CoerceScalarValue<double>(PropertyType.Double);
}
public char GetChar16()
return (char)_data;
}
- public Boolean GetBoolean()
+ public bool GetBoolean()
{
if (this.Type != PropertyType.Boolean)
throw new InvalidCastException(SR.Format(SR.InvalidCast_WinRTIPropertyValueElement, this.Type, "Boolean"), HResults.TYPE_E_TYPEMISMATCH);
return (bool)_data;
}
- public String GetString()
+ public string GetString()
{
- return CoerceScalarValue<String>(PropertyType.String);
+ return CoerceScalarValue<string>(PropertyType.String);
}
return Unbox<Rect>(IReferenceFactory.s_rectType);
}
- public Byte[] GetUInt8Array()
+ public byte[] GetUInt8Array()
{
- return CoerceArrayValue<Byte>(PropertyType.UInt8Array);
+ return CoerceArrayValue<byte>(PropertyType.UInt8Array);
}
- public Int16[] GetInt16Array()
+ public short[] GetInt16Array()
{
- return CoerceArrayValue<Int16>(PropertyType.Int16Array);
+ return CoerceArrayValue<short>(PropertyType.Int16Array);
}
- public UInt16[] GetUInt16Array()
+ public ushort[] GetUInt16Array()
{
- return CoerceArrayValue<UInt16>(PropertyType.UInt16Array);
+ return CoerceArrayValue<ushort>(PropertyType.UInt16Array);
}
- public Int32[] GetInt32Array()
+ public int[] GetInt32Array()
{
- return CoerceArrayValue<Int32>(PropertyType.Int32Array);
+ return CoerceArrayValue<int>(PropertyType.Int32Array);
}
- public UInt32[] GetUInt32Array()
+ public uint[] GetUInt32Array()
{
- return CoerceArrayValue<UInt32>(PropertyType.UInt32Array);
+ return CoerceArrayValue<uint>(PropertyType.UInt32Array);
}
- public Int64[] GetInt64Array()
+ public long[] GetInt64Array()
{
- return CoerceArrayValue<Int64>(PropertyType.Int64Array);
+ return CoerceArrayValue<long>(PropertyType.Int64Array);
}
- public UInt64[] GetUInt64Array()
+ public ulong[] GetUInt64Array()
{
- return CoerceArrayValue<UInt64>(PropertyType.UInt64Array);
+ return CoerceArrayValue<ulong>(PropertyType.UInt64Array);
}
- public Single[] GetSingleArray()
+ public float[] GetSingleArray()
{
- return CoerceArrayValue<Single>(PropertyType.SingleArray);
+ return CoerceArrayValue<float>(PropertyType.SingleArray);
}
- public Double[] GetDoubleArray()
+ public double[] GetDoubleArray()
{
- return CoerceArrayValue<Double>(PropertyType.DoubleArray);
+ return CoerceArrayValue<double>(PropertyType.DoubleArray);
}
public char[] GetChar16Array()
return (char[])_data;
}
- public Boolean[] GetBooleanArray()
+ public bool[] GetBooleanArray()
{
if (this.Type != PropertyType.BooleanArray)
throw new InvalidCastException(SR.Format(SR.InvalidCast_WinRTIPropertyValueElement, this.Type, "Boolean[]"), HResults.TYPE_E_TYPEMISMATCH);
return (bool[])_data;
}
- public String[] GetStringArray()
+ public string[] GetStringArray()
{
- return CoerceArrayValue<String>(PropertyType.StringArray);
+ return CoerceArrayValue<string>(PropertyType.StringArray);
}
- public Object[] GetInspectableArray()
+ public object[] GetInspectableArray()
{
if (this.Type != PropertyType.InspectableArray)
throw new InvalidCastException(SR.Format(SR.InvalidCast_WinRTIPropertyValueElement, this.Type, "Inspectable[]"), HResults.TYPE_E_TYPEMISMATCH);
- return (Object[])_data;
+ return (object[])_data;
}
public Guid[] GetGuidArray()
{
return (T)(object)Guid.Parse((string)value);
}
- else if (type == PropertyType.Guid && typeof(T) == typeof(String))
+ else if (type == PropertyType.Guid && typeof(T) == typeof(string))
{
return (T)(object)((Guid)value).ToString("D", System.Globalization.CultureInfo.InvariantCulture);
}
IPropertyValue ipv = value as IPropertyValue;
if (type == PropertyType.Inspectable && ipv != null)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
return (T)(object)ipv.GetUInt8();
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
return (T)(object)ipv.GetInt16();
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
return (T)(object)ipv.GetUInt16();
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
return (T)(object)ipv.GetUInt32();
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
return (T)(object)ipv.GetUInt32();
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
return (T)(object)ipv.GetInt64();
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
return (T)(object)ipv.GetUInt64();
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
return (T)(object)ipv.GetSingle();
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
return (T)(object)ipv.GetDouble();
}
// to the managed object, and free the native method. Also we want the return value boxed (aka normal value type boxing).
//
// This method is called by VM.
- internal static Object UnboxHelper(Object wrapper)
+ internal static object UnboxHelper(object wrapper)
{
Debug.Assert(wrapper != null);
IReference<T> reference = (IReference<T>)wrapper;
// IList & ICollection methods.
// This enables two-way data binding and index access in Jupiter
//
- Object IList.this[int index]
+ object IList.this[int index]
{
get
{
}
}
- int IList.Add(Object value)
+ int IList.Add(object value)
{
return _list.Add(value);
}
- bool IList.Contains(Object value)
+ bool IList.Contains(object value)
{
return _list.Contains(value);
}
}
}
- int IList.IndexOf(Object value)
+ int IList.IndexOf(object value)
{
return _list.IndexOf(value);
}
- void IList.Insert(int index, Object value)
+ void IList.Insert(int index, object value)
{
_list.Insert(index, value);
}
- void IList.Remove(Object value)
+ void IList.Remove(object value)
{
_list.Remove(value);
}
}
}
- Object ICollection.SyncRoot
+ object ICollection.SyncRoot
{
get
{
// to the managed object, and free the native method.
//
// This method is called by VM.
- internal static Object UnboxHelper(Object wrapper)
+ internal static object UnboxHelper(object wrapper)
{
Debug.Assert(wrapper != null);
IReferenceArray<T> reference = (IReferenceArray<T>)wrapper;
internal static readonly Type s_rectType = Type.GetType("Windows.Foundation.Rect, System.Runtime.WindowsRuntime");
internal static readonly Type s_sizeType = Type.GetType("Windows.Foundation.Size, System.Runtime.WindowsRuntime");
- internal static Object CreateIReference(Object obj)
+ internal static object CreateIReference(object obj)
{
Debug.Assert(obj != null, "Null should not be boxed.");
if (type == typeof(int))
return new CLRIReferenceImpl<int>(PropertyType.Int32, (int)obj);
- if (type == typeof(String))
- return new CLRIReferenceImpl<String>(PropertyType.String, (String)obj);
+ if (type == typeof(string))
+ return new CLRIReferenceImpl<string>(PropertyType.String, (string)obj);
if (type == typeof(byte))
return new CLRIReferenceImpl<byte>(PropertyType.UInt8, (byte)obj);
if (type == typeof(short))
return new CLRIReferenceImpl<DateTimeOffset>(PropertyType.DateTime, (DateTimeOffset)obj);
if (type == typeof(TimeSpan))
return new CLRIReferenceImpl<TimeSpan>(PropertyType.TimeSpan, (TimeSpan)obj);
- if (type == typeof(Object))
- return new CLRIReferenceImpl<Object>(PropertyType.Inspectable, (Object)obj);
+ if (type == typeof(object))
+ return new CLRIReferenceImpl<object>(PropertyType.Inspectable, (object)obj);
if (type == typeof(RuntimeType))
{ // If the type is System.RuntimeType, we want to use System.Type marshaler (it's parent of the type)
return new CLRIReferenceImpl<Type>(PropertyType.Other, (Type)obj);
if (propType.HasValue)
{
Type specificType = typeof(CLRIReferenceImpl<>).MakeGenericType(type);
- return Activator.CreateInstance(specificType, new Object[] { propType.Value, obj });
+ return Activator.CreateInstance(specificType, new object[] { propType.Value, obj });
}
Debug.Fail("We should not see non-WinRT type here");
return null;
}
- internal static Object CreateIReferenceArray(Array obj)
+ internal static object CreateIReferenceArray(Array obj)
{
Debug.Assert(obj != null);
Debug.Assert(obj.GetType().IsArray);
if (type == typeof(int))
return new CLRIReferenceArrayImpl<int>(PropertyType.Int32Array, (int[])obj);
- if (type == typeof(String))
- return new CLRIReferenceArrayImpl<String>(PropertyType.StringArray, (String[])obj);
+ if (type == typeof(string))
+ return new CLRIReferenceArrayImpl<string>(PropertyType.StringArray, (string[])obj);
if (type == typeof(byte))
return new CLRIReferenceArrayImpl<byte>(PropertyType.UInt8Array, (byte[])obj);
if (type == typeof(short))
if (type.IsGenericType &&
type.GetGenericTypeDefinition() == typeof(System.Collections.Generic.KeyValuePair<,>))
{
- Object[] objArray = new Object[obj.Length];
+ object[] objArray = new object[obj.Length];
for (int i = 0; i < objArray.Length; i++)
{
objArray[i] = obj.GetValue(i);
{
// All WinRT value type will be Property.Other
Type specificType = typeof(CLRIReferenceArrayImpl<>).MakeGenericType(type);
- return Activator.CreateInstance(specificType, new Object[] { propType.Value, obj });
+ return Activator.CreateInstance(specificType, new object[] { propType.Value, obj });
}
else
{
// All WinRT reference type (including arbitrary managed type) will be PropertyType.ObjectArray
- return new CLRIReferenceArrayImpl<Object>(PropertyType.InspectableArray, (Object[])obj);
+ return new CLRIReferenceArrayImpl<object>(PropertyType.InspectableArray, (object[])obj);
}
}
}
{
private static readonly IComparer<TKey> keyComparator = Comparer<TKey>.Default;
- public Int32 Compare(KeyValuePair<TKey, TValue> x, KeyValuePair<TKey, TValue> y)
+ public int Compare(KeyValuePair<TKey, TValue> x, KeyValuePair<TKey, TValue> y)
{
return keyComparator.Compare(x.Key, y.Key);
}
}
- private ConstantSplittableMap(KeyValuePair<TKey, TValue>[] items, Int32 firstItemIndex, Int32 lastItemIndex)
+ private ConstantSplittableMap(KeyValuePair<TKey, TValue>[] items, int firstItemIndex, int lastItemIndex)
{
this.items = items;
this.firstItemIndex = firstItemIndex;
}
- private KeyValuePair<TKey, TValue>[] CreateKeyValueArray(Int32 count, IEnumerator<KeyValuePair<TKey, TValue>> data)
+ private KeyValuePair<TKey, TValue>[] CreateKeyValueArray(int count, IEnumerator<KeyValuePair<TKey, TValue>> data)
{
KeyValuePair<TKey, TValue>[] kvArray = new KeyValuePair<TKey, TValue>[count];
- Int32 i = 0;
+ int i = 0;
while (data.MoveNext())
kvArray[i++] = data.Current;
// [CLSCompliant(false)]
- public UInt32 Size
+ public uint Size
{
get
{
- return (UInt32)(lastItemIndex - firstItemIndex + 1);
+ return (uint)(lastItemIndex - firstItemIndex + 1);
}
}
return;
}
- int pivot = (Int32)(((Int64)firstItemIndex + (Int64)lastItemIndex) / (Int64)2);
+ int pivot = (int)(((long)firstItemIndex + (long)lastItemIndex) / (long)2);
firstPartition = new ConstantSplittableMap<TKey, TValue>(items, firstItemIndex, pivot);
secondPartition = new ConstantSplittableMap<TKey, TValue>(items, pivot + 1, lastItemIndex);
}
}
- Object IEnumerator.Current
+ object IEnumerator.Current
{
get
{
return enumeration.MoveNext();
}
- Object IEnumerator.Current
+ object IEnumerator.Current
{
get { return ((IEnumerator<TKey>)this).Current; }
}
return enumeration.MoveNext();
}
- Object IEnumerator.Current
+ object IEnumerator.Current
{
get { return ((IEnumerator<TValue>)this).Current; }
}
{
string[] stringItems = items as string[];
- // Fill the rest of the array with String.Empty to avoid marshaling failure
+ // Fill the rest of the array with string.Empty to avoid marshaling failure
for (int i = index; i < items.Length; ++i)
stringItems[i] = string.Empty;
}
return enumeration.MoveNext();
}
- Object IEnumerator.Current
+ object IEnumerator.Current
{
get { return ((IEnumerator<TKey>)this).Current; }
}
return enumeration.MoveNext();
}
- Object IEnumerator.Current
+ object IEnumerator.Current
{
get { return ((IEnumerator<TValue>)this).Current; }
}
get;
}
- Byte GetUInt8();
+ byte GetUInt8();
- Int16 GetInt16();
+ short GetInt16();
- UInt16 GetUInt16();
+ ushort GetUInt16();
- Int32 GetInt32();
+ int GetInt32();
- UInt32 GetUInt32();
+ uint GetUInt32();
- Int64 GetInt64();
+ long GetInt64();
- UInt64 GetUInt64();
+ ulong GetUInt64();
- Single GetSingle();
+ float GetSingle();
- Double GetDouble();
+ double GetDouble();
char GetChar16();
- Boolean GetBoolean();
+ bool GetBoolean();
- String GetString();
+ string GetString();
Guid GetGuid();
Rect GetRect();
- Byte[] GetUInt8Array();
+ byte[] GetUInt8Array();
- Int16[] GetInt16Array();
+ short[] GetInt16Array();
- UInt16[] GetUInt16Array();
+ ushort[] GetUInt16Array();
- Int32[] GetInt32Array();
+ int[] GetInt32Array();
- UInt32[] GetUInt32Array();
+ uint[] GetUInt32Array();
- Int64[] GetInt64Array();
+ long[] GetInt64Array();
- UInt64[] GetUInt64Array();
+ ulong[] GetUInt64Array();
- Single[] GetSingleArray();
+ float[] GetSingleArray();
- Double[] GetDoubleArray();
+ double[] GetDoubleArray();
char[] GetChar16Array();
- Boolean[] GetBooleanArray();
+ bool[] GetBooleanArray();
- String[] GetStringArray();
+ string[] GetStringArray();
object[] GetInspectableArray();
{
string[] stringItems = items as string[];
- // Fill in the rest of the array with String.Empty to avoid marshaling failure
+ // Fill in the rest of the array with string.Empty to avoid marshaling failure
for (uint i = itemCount; i < items.Length; ++i)
stringItems[i] = string.Empty;
}
private static void EnsureIndexInt32(uint index, int listCapacity)
{
- // We use '<=' and not '<' because Int32.MaxValue == index would imply
- // that Size > Int32.MaxValue:
- if (((uint)Int32.MaxValue) <= index || index >= (uint)listCapacity)
+ // We use '<=' and not '<' because int.MaxValue == index would imply
+ // that Size > int.MaxValue:
+ if (((uint)int.MaxValue) <= index || index >= (uint)listCapacity)
{
Exception e = new ArgumentOutOfRangeException(nameof(index), SR.ArgumentOutOfRange_IndexLargerThanMaxValue);
e.HResult = HResults.E_BOUNDS;
try
{
- return _this[(Int32)index];
+ return _this[(int)index];
}
catch (ArgumentOutOfRangeException ex)
{
try
{
- _this.RemoveAt((Int32)index);
+ _this.RemoveAt((int)index);
}
catch (ArgumentOutOfRangeException ex)
{
private static void EnsureIndexInt32(uint index, int listCapacity)
{
- // We use '<=' and not '<' becasue Int32.MaxValue == index would imply
- // that Size > Int32.MaxValue:
- if (((uint)Int32.MaxValue) <= index || index >= (uint)listCapacity)
+ // We use '<=' and not '<' becasue int.MaxValue == index would imply
+ // that Size > int.MaxValue:
+ if (((uint)int.MaxValue) <= index || index >= (uint)listCapacity)
{
Exception e = new ArgumentOutOfRangeException(nameof(index), SR.ArgumentOutOfRange_IndexLargerThanMaxValue);
e.HResult = HResults.E_BOUNDS;
private static void EnsureIndexInt32(uint index, int listCapacity)
{
- // We use '<=' and not '<' becasue Int32.MaxValue == index would imply
- // that Size > Int32.MaxValue:
- if (((uint)Int32.MaxValue) <= index || index >= (uint)listCapacity)
+ // We use '<=' and not '<' becasue int.MaxValue == index would imply
+ // that Size > int.MaxValue:
+ if (((uint)int.MaxValue) <= index || index >= (uint)listCapacity)
{
Exception e = new ArgumentOutOfRangeException(nameof(index), SR.ArgumentOutOfRange_IndexLargerThanMaxValue);
e.HResult = HResults.E_BOUNDS;
try
{
- return _this[(Int32)index];
+ return _this[(int)index];
}
catch (ArgumentOutOfRangeException ex)
{
try
{
- _this.RemoveAt((Int32)index);
+ _this.RemoveAt((int)index);
}
catch (ArgumentOutOfRangeException ex)
{
private static void EnsureIndexInt32(uint index, int listCapacity)
{
- // We use '<=' and not '<' becasue Int32.MaxValue == index would imply
- // that Size > Int32.MaxValue:
- if (((uint)Int32.MaxValue) <= index || index >= (uint)listCapacity)
+ // We use '<=' and not '<' becasue int.MaxValue == index would imply
+ // that Size > int.MaxValue:
+ if (((uint)int.MaxValue) <= index || index >= (uint)listCapacity)
{
Exception e = new ArgumentOutOfRangeException(nameof(index), SR.ArgumentOutOfRange_IndexLargerThanMaxValue);
e.HResult = HResults.E_BOUNDS;
{
string[] stringItems = items as string[];
- // Fill in rest of the array with String.Empty to avoid marshaling failure
+ // Fill in rest of the array with string.Empty to avoid marshaling failure
for (uint i = itemCount; i < items.Length; ++i)
stringItems[i] = string.Empty;
}
{
uint size = _this_map.Size;
- if (((uint)Int32.MaxValue) < size)
+ if (((uint)int.MaxValue) < size)
{
throw new InvalidOperationException(SR.InvalidOperation_CollectionBackingDictionaryTooLarge);
}
IVector<KeyValuePair<K, V>> _this_vector = Unsafe.As<IVector<KeyValuePair<K, V>>>(this);
uint size = _this_vector.Size;
- if (((uint)Int32.MaxValue) < size)
+ if (((uint)int.MaxValue) < size)
{
throw new InvalidOperationException(SR.InvalidOperation_CollectionBackingListTooLarge);
}
if (!exists)
return false;
- if (((uint)Int32.MaxValue) < index)
+ if (((uint)int.MaxValue) < index)
{
throw new InvalidOperationException(SR.InvalidOperation_CollectionBackingListTooLarge);
}
{
uint size = _this_map.Size;
- if (((uint)Int32.MaxValue) < size)
+ if (((uint)int.MaxValue) < size)
{
throw new InvalidOperationException(SR.InvalidOperation_CollectionBackingDictionaryTooLarge);
}
IVectorView<KeyValuePair<K, V>> _this_vector = Unsafe.As<IVectorView<KeyValuePair<K, V>>>(this);
uint size = _this_vector.Size;
- if (((uint)Int32.MaxValue) < size)
+ if (((uint)int.MaxValue) < size)
{
throw new InvalidOperationException(SR.InvalidOperation_CollectionBackingListTooLarge);
}
{
IVector<T> _this = Unsafe.As<IVector<T>>(this);
uint size = _this.Size;
- if (((uint)Int32.MaxValue) < size)
+ if (((uint)int.MaxValue) < size)
{
throw new InvalidOperationException(SR.InvalidOperation_CollectionBackingListTooLarge);
}
if (!exists)
return false;
- if (((uint)Int32.MaxValue) < index)
+ if (((uint)int.MaxValue) < index)
{
throw new InvalidOperationException(SR.InvalidOperation_CollectionBackingListTooLarge);
}
if (!exists)
return -1;
- if (((uint)Int32.MaxValue) < index)
+ if (((uint)int.MaxValue) < index)
{
throw new InvalidOperationException(SR.InvalidOperation_CollectionBackingListTooLarge);
}
}
}
- private static void SetAt<T>(IVector<T> _this, UInt32 index, T value)
+ private static void SetAt<T>(IVector<T> _this, uint index, T value)
{
try
{
{
IVectorView<T> _this = Unsafe.As<IVectorView<T>>(this);
uint size = _this.Size;
- if (((uint)Int32.MaxValue) < size)
+ if (((uint)int.MaxValue) < size)
{
throw new InvalidOperationException(SR.InvalidOperation_CollectionBackingListTooLarge);
}
public bool Equals(EventCacheKey other)
{
- return (Object.Equals(target, other.target) && Object.Equals(method, other.method));
+ return (object.Equals(target, other.target) && object.Equals(method, other.method));
}
public int GetHashCode(EventCacheKey key)
{
foreach (KeyValuePair<object, EventRegistrationTokenListWithCount> item in registrationTable)
{
- if (Object.Equals(item.Key, handler))
+ if (object.Equals(item.Key, handler))
{
tokens = item.Value;
return item.Key;
{
uint length;
char* rawBuffer = UnsafeNativeMethods.WindowsGetStringRawBuffer(hstring, &length);
- return new String(rawBuffer, 0, checked((int)length));
+ return new string(rawBuffer, 0, checked((int)length));
}
}
// HSTRING marshaling methods:
- public static IntPtr StringToHString(String s)
+ public static IntPtr StringToHString(string s)
{
if (!Environment.IsWinRTSupported)
throw new PlatformNotSupportedException(SR.PlatformNotSupported_WinRT);
// Custom AssemblyLoadContext implementations can override this
// method to perform the load of unmanaged native dll
// This function needs to return the HMODULE of the dll it loads
- protected virtual IntPtr LoadUnmanagedDll(String unmanagedDllName)
+ protected virtual IntPtr LoadUnmanagedDll(string unmanagedDllName)
{
//defer to default coreclr policy of loading unmanaged dll
return IntPtr.Zero;
// This method is invoked by the VM when using the host-provided assembly load context
// implementation.
- private static IntPtr ResolveUnmanagedDll(String unmanagedDllName, IntPtr gchManagedAssemblyLoadContext)
+ private static IntPtr ResolveUnmanagedDll(string unmanagedDllName, IntPtr gchManagedAssemblyLoadContext)
{
AssemblyLoadContext context = (AssemblyLoadContext)(GCHandle.FromIntPtr(gchManagedAssemblyLoadContext).Target);
return context.LoadUnmanagedDll(unmanagedDllName);
private static volatile AssemblyLoadContext s_DefaultAssemblyLoadContext;
// Synchronization primitive for controlling initialization of Default load context
- private static readonly object s_initLock = new Object();
+ private static readonly object s_initLock = new object();
// Occurs when an Assembly is loaded
public static event AssemblyLoadEventHandler AssemblyLoad
// will not create an unitialized string because it is non-sensical to create an empty
// instance of an immutable type.
//
- public static Object GetUninitializedObject(Type type)
+ public static object GetUninitializedObject(Type type)
{
if ((object)type == null)
{
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern Object nativeGetUninitializedObject(RuntimeType type);
+ private static extern object nativeGetUninitializedObject(RuntimeType type);
}
}
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern bool IsInstanceOfType(RuntimeType type, Object o);
+ internal static extern bool IsInstanceOfType(RuntimeType type, object o);
internal static unsafe Type GetTypeHelper(Type typeStart, Type[] genericArgs, IntPtr pModifiers, int cModifiers)
{
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern Object CreateInstance(RuntimeType type, bool publicOnly, bool wrapExceptions, ref bool canBeCached, ref RuntimeMethodHandleInternal ctor);
+ internal static extern object CreateInstance(RuntimeType type, bool publicOnly, bool wrapExceptions, ref bool canBeCached, ref RuntimeMethodHandleInternal ctor);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern Object CreateCaInstance(RuntimeType type, IRuntimeMethodInfo ctor);
+ internal static extern object CreateCaInstance(RuntimeType type, IRuntimeMethodInfo ctor);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern Object Allocate(RuntimeType type);
+ internal static extern object Allocate(RuntimeType type);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern Object CreateInstanceForAnotherGenericParameter(RuntimeType type, RuntimeType genericParameter);
+ internal static extern object CreateInstanceForAnotherGenericParameter(RuntimeType type, RuntimeType genericParameter);
internal RuntimeType GetRuntimeType()
{
RuntimeType type = null;
- Object keepAlive = null;
+ object keepAlive = null;
GetTypeByName(name, throwOnError, ignoreCase, reflectionOnly,
JitHelpers.GetStackCrawlMarkHandle(ref stackMark),
pPrivHostBinder,
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern String GetName(RtFieldInfo field);
+ internal static extern string GetName(RtFieldInfo field);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private static extern unsafe void* _GetUtf8Name(RuntimeFieldHandleInternal field);
internal static extern int GetToken(RtFieldInfo field);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern Object GetValue(RtFieldInfo field, Object instance, RuntimeType fieldType, RuntimeType declaringType, ref bool domainInitialized);
+ internal static extern object GetValue(RtFieldInfo field, object instance, RuntimeType fieldType, RuntimeType declaringType, ref bool domainInitialized);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern Object GetValueDirect(RtFieldInfo field, RuntimeType fieldType, void* pTypedRef, RuntimeType contextType);
+ internal static extern object GetValueDirect(RtFieldInfo field, RuntimeType fieldType, void* pTypedRef, RuntimeType contextType);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern void SetValue(RtFieldInfo field, Object obj, Object value, RuntimeType fieldType, FieldAttributes fieldAttr, RuntimeType declaringType, ref bool domainInitialized);
+ internal static extern void SetValue(RtFieldInfo field, object obj, object value, RuntimeType fieldType, FieldAttributes fieldAttr, RuntimeType declaringType, ref bool domainInitialized);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern void SetValueDirect(RtFieldInfo field, RuntimeType fieldType, void* pTypedRef, Object value, RuntimeType contextType);
+ internal static extern void SetValueDirect(RtFieldInfo field, RuntimeType fieldType, void* pTypedRef, object value, RuntimeType contextType);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern RuntimeFieldHandleInternal GetStaticFieldForGenericType(RuntimeFieldHandleInternal field, RuntimeType declaringType);
internal abstract unsafe void GetEHInfo(int EHNumber, void* exception);
internal abstract unsafe byte[] GetRawEHInfo();
// token resolution
- internal abstract String GetStringLiteral(int token);
+ internal abstract string GetStringLiteral(int token);
internal abstract void ResolveToken(int token, out IntPtr typeHandle, out IntPtr methodHandle, out IntPtr fieldHandle);
internal abstract byte[] ResolveSignature(int token, int fromMethod);
//
// We need to call the String constructor so that the compiler doesn't mark this as a literal.
// Marking this as a literal would mean that it doesn't show up as a field which we can access
// from native.
- public static readonly String Empty;
+ public static readonly string Empty;
// Gets the character at a specified position.
//
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern String FastAllocateString(int length);
+ internal static extern string FastAllocateString(int length);
// Is this a string that can be compared quickly (that is it has only characters > 0x80
// and not a - or '
internal extern bool TryGetTrailByte(out byte data);
#endif
- public static String Intern(String str)
+ public static string Intern(string str)
{
if (str == null)
{
return Thread.GetDomain().GetOrInternString(str);
}
- public static String IsInterned(String str)
+ public static string IsInterned(string str)
{
if (str == null)
{
}
// Copies the source String (byte buffer) to the destination IntPtr memory allocated with len bytes.
- internal static unsafe void InternalCopy(String src, IntPtr dest, int len)
+ internal static unsafe void InternalCopy(string src, IntPtr dest, int len)
{
if (len == 0)
return;
if (IntPtr.Zero == cstr)
return null;
else
- return new String((sbyte*)cstr);
+ return new string((sbyte*)cstr);
}
internal static void ClearNative(IntPtr pNative)
// In the empty string case, we need to use FastAllocateString rather than the
// String .ctor, since newing up a 0 sized string will always return String.Emtpy.
// When we marshal that out as a bstr, it can wind up getting modified which
- // corrupts String.Empty.
+ // corrupts string.Empty.
ret = string.FastAllocateString(0);
}
else
{
- ret = new String((char*)bstr, 0, (int)(length / 2));
+ ret = new string((char*)bstr, 0, (int)(length / 2));
}
if ((length & 1) == 1)
return null;
}
- return new String((sbyte*)pNative, 0, cch);
+ return new string((sbyte*)pNative, 0, cch);
}
internal static unsafe void ClearNative(IntPtr pNative)
// We intentionally ignore the length field of the BSTR for back compat reasons.
// Unfortunately VB.NET uses Ansi BSTR marshaling when a string is passed ByRef
// and we cannot afford to break this common scenario.
- return new String((sbyte*)bstr);
+ return new string((sbyte*)bstr);
}
}
[StructLayout(LayoutKind.Sequential)]
internal struct DateTimeNative
{
- public Int64 UniversalTime;
+ public long UniversalTime;
};
internal static class DateTimeOffsetMarshaler
{
// Numer of ticks counted between 0001-01-01, 00:00:00 and 1601-01-01, 00:00:00.
// You can get this through: (new DateTimeOffset(1601, 1, 1, 0, 0, 1, TimeSpan.Zero)).Ticks;
- private const Int64 ManagedUtcTicksAtNativeZero = 504911232000000000;
+ private const long ManagedUtcTicksAtNativeZero = 504911232000000000;
internal static void ConvertToNative(ref DateTimeOffset managedDTO, out DateTimeNative dateTime)
{
- Int64 managedUtcTicks = managedDTO.UtcTicks;
+ long managedUtcTicks = managedDTO.UtcTicks;
dateTime.UniversalTime = managedUtcTicks - ManagedUtcTicksAtNativeZero;
}
internal static void ConvertToManaged(out DateTimeOffset managedLocalDTO, ref DateTimeNative nativeTicks)
{
- Int64 managedUtcTicks = ManagedUtcTicksAtNativeZero + nativeTicks.UniversalTime;
+ long managedUtcTicks = ManagedUtcTicksAtNativeZero + nativeTicks.UniversalTime;
DateTimeOffset managedUtcDTO = new DateTimeOffset(managedUtcTicks, TimeSpan.Zero);
// Some Utc times cannot be represented in local time in certain timezones. E.g. 0001-01-01 12:00:00 AM cannot
{
if (managedArray != null)
{
- Int32* nativeBuffer = *(Int32**)pNativeHome;
+ int* nativeBuffer = *(int**)pNativeHome;
for (int i = 0; i < managedArray.Length; i++)
{
nativeBuffer[i] = HResultExceptionMarshaler.ConvertToNative(managedArray[i]);
{
if (managedArray != null)
{
- Int32* nativeBuffer = *(Int32**)pNativeHome;
+ int* nativeBuffer = *(int**)pNativeHome;
for (int i = 0; i < managedArray.Length; i++)
{
managedArray[i] = HResultExceptionMarshaler.ConvertToManaged(nativeBuffer[i]);
private IntPtr data1;
private IntPtr data2;
#else
- Int64 data1;
+ long data1;
#endif
} // struct NativeVariant
internal static extern unsafe int strlen(sbyte* ptr);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern void DecimalCanonicalizeInternal(ref Decimal dec);
+ internal static extern void DecimalCanonicalizeInternal(ref decimal dec);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern unsafe void FmtClassUpdateNativeInternal(object obj, byte* pNative, ref CleanupWorkList pCleanupWorkList);
{
internal int m_dataIndex;
internal int m_uiFamilyCodePage;
- internal String m_webName;
- internal String m_headerName;
- internal String m_bodyName;
+ internal string m_webName;
+ internal string m_headerName;
+ internal string m_bodyName;
internal uint m_flags;
internal unsafe CodePageDataItem(int dataIndex)
m_flags = EncodingTable.codePageDataPtr[dataIndex].flags;
}
- internal static unsafe String CreateString(sbyte* pStrings, uint index)
+ internal static unsafe string CreateString(sbyte* pStrings, uint index)
{
if (pStrings[0] == '|') // |str1|str2|str3
{
{
if (index == 0)
{
- return new String(pStrings, start, i - start);
+ return new string(pStrings, start, i - start);
}
index--;
}
else
{
- return new String(pStrings);
+ return new string(pStrings);
}
}
- public unsafe String WebName
+ public unsafe string WebName
{
get
{
}
}
- public unsafe String HeaderName
+ public unsafe string HeaderName
{
get
{
}
}
- public unsafe String BodyName
+ public unsafe string BodyName
{
get
{
// Find the data item by binary searching the table that we have in native.
// nativeCompareOrdinalWC is an internal-only function.
- private static unsafe int internalGetCodePageFromName(String name)
+ private static unsafe int internalGetCodePageFromName(string name)
{
int left = 0;
int right = lastEncodingItem;
** internalGetCodePageFromName will throw ArgumentException if name is not a valid encoding name.
============================================================================*/
- internal static int GetCodePageFromName(String name)
+ internal static int GetCodePageFromName(string name)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
- Object codePageObj;
+ object codePageObj;
//
// The name is case-insensitive, but ToLower isn't free. Check for
//This will not work in case-insensitive mode for any character greater than 0x7F.
//We'll throw an ArgumentException.
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern unsafe int nativeCompareOrdinalIgnoreCaseWC(String strA, sbyte* strBBytes);
+ private static extern unsafe int nativeCompareOrdinalIgnoreCaseWC(string strA, sbyte* strBBytes);
}
/*=================================InternalEncodingDataItem==========================
internal unsafe struct InternalEncodingDataItem
{
internal sbyte* webName;
- internal UInt16 codePage;
+ internal ushort codePage;
}
/*=================================InternalCodePageDataItem==========================
[System.Runtime.InteropServices.StructLayout(LayoutKind.Sequential)]
internal unsafe struct InternalCodePageDataItem
{
- internal UInt16 codePage;
- internal UInt16 uiFamilyCodePage;
+ internal ushort codePage;
+ internal ushort uiFamilyCodePage;
internal uint flags;
internal sbyte* Names;
}
/// </summary>
/// <param name="delay">The time span to wait before canceling this <see cref="CancellationTokenSource"/></param>
/// <exception cref="ArgumentOutOfRangeException">
- /// The exception that is thrown when <paramref name="delay"/> is less than -1 or greater than Int32.MaxValue.
+ /// The exception that is thrown when <paramref name="delay"/> is less than -1 or greater than int.MaxValue.
/// </exception>
/// <remarks>
/// <para>
/// </exception>
/// <exception cref="ArgumentOutOfRangeException">
/// The exception thrown when <paramref name="delay"/> is less than -1 or
- /// greater than Int32.MaxValue.
+ /// greater than int.MaxValue.
/// </exception>
/// <remarks>
/// <para>
public static extern double Exchange(ref double location1, double value);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern Object Exchange(ref Object location1, Object value);
+ public static extern object Exchange(ref object location1, object value);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern IntPtr Exchange(ref IntPtr location1, IntPtr value);
public static extern double CompareExchange(ref double location1, double value, double comparand);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern Object CompareExchange(ref Object location1, Object value, Object comparand);
+ public static extern object CompareExchange(ref object location1, object value, object comparand);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
public static extern IntPtr CompareExchange(ref IntPtr location1, IntPtr value, IntPtr comparand);
// -- State -- //
//For a packed word a uint would seem better, but Interlocked.* doesn't support them as uint isn't CLS-compliant.
- private volatile int m_combinedState; //ie a UInt32. Used for the state items listed below.
+ private volatile int m_combinedState; //ie a uint. Used for the state items listed below.
//1-bit for signalled state
private const int SignalledState_BitMask = unchecked((int)0x80000000);//1000 0000 0000 0000 0000 0000 0000 0000
/// false.</returns>
/// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="timeout"/> is a negative
/// number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater
- /// than <see cref="System.Int32.MaxValue"/>.</exception>
+ /// than <see cref="System.int.MaxValue"/>.</exception>
/// <exception cref="T:System.InvalidOperationException">
/// The maximum number of waiters has been exceeded.
/// </exception>
/// false.</returns>
/// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="timeout"/> is a negative
/// number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater
- /// than <see cref="System.Int32.MaxValue"/>.</exception>
+ /// than <see cref="System.int.MaxValue"/>.</exception>
/// <exception cref="T:System.Threading.OperationCanceledException"><paramref
/// name="cancellationToken"/> was canceled.</exception>
/// <exception cref="T:System.InvalidOperationException">
/// <param name="disposing">true to release both managed and unmanaged resources;
/// false to release only unmanaged resources.</param>
/// <remarks>
- /// Unlike most of the members of <see cref="ManualResetEventSlim"/>, <see cref="Dispose(Boolean)"/> is not
+ /// Unlike most of the members of <see cref="ManualResetEventSlim"/>, <see cref="Dispose(bool)"/> is not
/// thread-safe and may not be used concurrently with other members of this instance.
/// </remarks>
protected virtual void Dispose(bool disposing)
** Exceptions: ArgumentNullException if object is null.
=========================================================================*/
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern void Enter(Object obj);
+ public static extern void Enter(object obj);
// Use a ref bool instead of out to ensure that unverifiable code must
// could be uninitialized if we threw an exception in our prolog.
// The JIT should inline this method to allow check of lockTaken argument to be optimized out
// in the typical case. Note that the method has to be transparent for inlining to be allowed by the VM.
- public static void Enter(Object obj, ref bool lockTaken)
+ public static void Enter(object obj, ref bool lockTaken)
{
if (lockTaken)
ThrowLockTakenException();
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void ReliableEnter(Object obj, ref bool lockTaken);
+ private static extern void ReliableEnter(object obj, ref bool lockTaken);
** own the lock.
=========================================================================*/
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public static extern void Exit(Object obj);
+ public static extern void Exit(object obj);
/*=========================================================================
** Similar to Enter, but will never block. That is, if the current thread can
**
** Exceptions: ArgumentNullException if object is null.
=========================================================================*/
- public static bool TryEnter(Object obj)
+ public static bool TryEnter(object obj)
{
bool lockTaken = false;
TryEnter(obj, 0, ref lockTaken);
// The JIT should inline this method to allow check of lockTaken argument to be optimized out
// in the typical case. Note that the method has to be transparent for inlining to be allowed by the VM.
- public static void TryEnter(Object obj, ref bool lockTaken)
+ public static void TryEnter(object obj, ref bool lockTaken)
{
if (lockTaken)
ThrowLockTakenException();
=========================================================================*/
// The JIT should inline this method to allow check of lockTaken argument to be optimized out
// in the typical case. Note that the method has to be transparent for inlining to be allowed by the VM.
- public static bool TryEnter(Object obj, int millisecondsTimeout)
+ public static bool TryEnter(object obj, int millisecondsTimeout)
{
bool lockTaken = false;
TryEnter(obj, millisecondsTimeout, ref lockTaken);
private static int MillisecondsTimeoutFromTimeSpan(TimeSpan timeout)
{
long tm = (long)timeout.TotalMilliseconds;
- if (tm < -1 || tm > (long)Int32.MaxValue)
+ if (tm < -1 || tm > (long)int.MaxValue)
throw new ArgumentOutOfRangeException(nameof(timeout), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
return (int)tm;
}
- public static bool TryEnter(Object obj, TimeSpan timeout)
+ public static bool TryEnter(object obj, TimeSpan timeout)
{
return TryEnter(obj, MillisecondsTimeoutFromTimeSpan(timeout));
}
// The JIT should inline this method to allow check of lockTaken argument to be optimized out
// in the typical case. Note that the method has to be transparent for inlining to be allowed by the VM.
- public static void TryEnter(Object obj, int millisecondsTimeout, ref bool lockTaken)
+ public static void TryEnter(object obj, int millisecondsTimeout, ref bool lockTaken)
{
if (lockTaken)
ThrowLockTakenException();
ReliableEnterTimeout(obj, millisecondsTimeout, ref lockTaken);
}
- public static void TryEnter(Object obj, TimeSpan timeout, ref bool lockTaken)
+ public static void TryEnter(object obj, TimeSpan timeout, ref bool lockTaken)
{
if (lockTaken)
ThrowLockTakenException();
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void ReliableEnterTimeout(Object obj, int timeout, ref bool lockTaken);
+ private static extern void ReliableEnterTimeout(object obj, int timeout, ref bool lockTaken);
public static bool IsEntered(object obj)
{
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern bool IsEnteredNative(Object obj);
+ private static extern bool IsEnteredNative(object obj);
/*========================================================================
** Waits for notification from the object (via a Pulse/PulseAll).
** Exceptions: ArgumentNullException if object is null.
========================================================================*/
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern bool ObjWait(bool exitContext, int millisecondsTimeout, Object obj);
+ private static extern bool ObjWait(bool exitContext, int millisecondsTimeout, object obj);
- public static bool Wait(Object obj, int millisecondsTimeout, bool exitContext)
+ public static bool Wait(object obj, int millisecondsTimeout, bool exitContext)
{
if (obj == null)
throw (new ArgumentNullException(nameof(obj)));
return ObjWait(exitContext, millisecondsTimeout, obj);
}
- public static bool Wait(Object obj, TimeSpan timeout, bool exitContext)
+ public static bool Wait(object obj, TimeSpan timeout, bool exitContext)
{
return Wait(obj, MillisecondsTimeoutFromTimeSpan(timeout), exitContext);
}
- public static bool Wait(Object obj, int millisecondsTimeout)
+ public static bool Wait(object obj, int millisecondsTimeout)
{
return Wait(obj, millisecondsTimeout, false);
}
- public static bool Wait(Object obj, TimeSpan timeout)
+ public static bool Wait(object obj, TimeSpan timeout)
{
return Wait(obj, MillisecondsTimeoutFromTimeSpan(timeout), false);
}
- public static bool Wait(Object obj)
+ public static bool Wait(object obj)
{
return Wait(obj, Timeout.Infinite, false);
}
* a synchronized block of code.
========================================================================*/
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void ObjPulse(Object obj);
+ private static extern void ObjPulse(object obj);
- public static void Pulse(Object obj)
+ public static void Pulse(object obj)
{
if (obj == null)
{
** Sends a notification to all waiting objects.
========================================================================*/
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern void ObjPulseAll(Object obj);
+ private static extern void ObjPulseAll(object obj);
- public static void PulseAll(Object obj)
+ public static void PulseAll(object obj)
{
if (obj == null)
{
internal ref int OffsetHigh => ref (_pNativeOverlapped != null) ? ref _pNativeOverlapped->OffsetHigh : ref _offsetHigh;
internal ref IntPtr EventHandle => ref (_pNativeOverlapped != null) ? ref _pNativeOverlapped->EventHandle : ref _eventHandle;
- internal unsafe NativeOverlapped* Pack(IOCompletionCallback iocb, Object userData)
+ internal unsafe NativeOverlapped* Pack(IOCompletionCallback iocb, object userData)
{
if (_pNativeOverlapped != null)
{
return AllocateNativeOverlapped();
}
- internal unsafe NativeOverlapped* UnsafePack(IOCompletionCallback iocb, Object userData)
+ internal unsafe NativeOverlapped* UnsafePack(IOCompletionCallback iocb, object userData)
{
if (_pNativeOverlapped != null)
{
new Task<bool>(false, false, (TaskCreationOptions)InternalTaskOptions.DoNotDispose, default);
// No maximum constant
- private const int NO_MAXIMUM = Int32.MaxValue;
+ private const int NO_MAXIMUM = int.MaxValue;
// Task in a linked list of asynchronous waiters
private sealed class TaskNode : Task<bool>, IThreadPoolWorkItem
/// otherwise, false.</returns>
/// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="timeout"/> is a negative
/// number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater
- /// than <see cref="System.Int32.MaxValue"/>.</exception>
+ /// than <see cref="System.int.MaxValue"/>.</exception>
public bool Wait(TimeSpan timeout)
{
// Validate the timeout
- Int64 totalMilliseconds = (Int64)timeout.TotalMilliseconds;
- if (totalMilliseconds < -1 || totalMilliseconds > Int32.MaxValue)
+ long totalMilliseconds = (long)timeout.TotalMilliseconds;
+ if (totalMilliseconds < -1 || totalMilliseconds > int.MaxValue)
{
throw new System.ArgumentOutOfRangeException(
nameof(timeout), timeout, SR.SemaphoreSlim_Wait_TimeoutWrong);
/// otherwise, false.</returns>
/// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="timeout"/> is a negative
/// number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater
- /// than <see cref="System.Int32.MaxValue"/>.</exception>
+ /// than <see cref="System.int.MaxValue"/>.</exception>
/// <exception cref="System.OperationCanceledException"><paramref name="cancellationToken"/> was canceled.</exception>
public bool Wait(TimeSpan timeout, CancellationToken cancellationToken)
{
// Validate the timeout
- Int64 totalMilliseconds = (Int64)timeout.TotalMilliseconds;
- if (totalMilliseconds < -1 || totalMilliseconds > Int32.MaxValue)
+ long totalMilliseconds = (long)timeout.TotalMilliseconds;
+ if (totalMilliseconds < -1 || totalMilliseconds > int.MaxValue)
{
throw new System.ArgumentOutOfRangeException(
nameof(timeout), timeout, SR.SemaphoreSlim_Wait_TimeoutWrong);
/// </exception>
/// <exception cref="T:System.ArgumentOutOfRangeException">
/// <paramref name="timeout"/> is a negative number other than -1 milliseconds, which represents
- /// an infinite time-out -or- timeout is greater than <see cref="System.Int32.MaxValue"/>.
+ /// an infinite time-out -or- timeout is greater than <see cref="System.int.MaxValue"/>.
/// </exception>
public Task<bool> WaitAsync(TimeSpan timeout)
{
/// </returns>
/// <exception cref="T:System.ArgumentOutOfRangeException">
/// <paramref name="timeout"/> is a negative number other than -1 milliseconds, which represents
- /// an infinite time-out -or- timeout is greater than <see cref="System.Int32.MaxValue"/>.
+ /// an infinite time-out -or- timeout is greater than <see cref="System.int.MaxValue"/>.
/// </exception>
public Task<bool> WaitAsync(TimeSpan timeout, CancellationToken cancellationToken)
{
// Validate the timeout
- Int64 totalMilliseconds = (Int64)timeout.TotalMilliseconds;
- if (totalMilliseconds < -1 || totalMilliseconds > Int32.MaxValue)
+ long totalMilliseconds = (long)timeout.TotalMilliseconds;
+ if (totalMilliseconds < -1 || totalMilliseconds > int.MaxValue)
{
throw new System.ArgumentOutOfRangeException(
nameof(timeout), timeout, SR.SemaphoreSlim_Wait_TimeoutWrong);
/// <param name="disposing">true to release both managed and unmanaged resources;
/// false to release only unmanaged resources.</param>
/// <remarks>
- /// Unlike most of the members of <see cref="SemaphoreSlim"/>, <see cref="Dispose(Boolean)"/> is not
+ /// Unlike most of the members of <see cref="SemaphoreSlim"/>, <see cref="Dispose(bool)"/> is not
/// thread-safe and may not be used concurrently with other members of this instance.
/// </remarks>
protected virtual void Dispose(bool disposing)
/// </exception>
/// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="timeout"/> is a negative
/// number other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater
- /// than <see cref="System.Int32.MaxValue"/> milliseconds.
+ /// than <see cref="System.int.MaxValue"/> milliseconds.
/// </exception>
public void TryEnter(TimeSpan timeout, ref bool lockTaken)
{
// Validate the timeout
- Int64 totalMilliseconds = (Int64)timeout.TotalMilliseconds;
+ long totalMilliseconds = (long)timeout.TotalMilliseconds;
if (totalMilliseconds < -1 || totalMilliseconds > int.MaxValue)
{
throw new System.ArgumentOutOfRangeException(
/// </summary>
/// <remarks>
/// The default overload of <see cref="Exit()"/> provides the same behavior as if calling <see
- /// cref="Exit(Boolean)"/> using true as the argument, but Exit() could be slightly faster than Exit(true).
+ /// cref="Exit(bool)"/> using true as the argument, but Exit() could be slightly faster than Exit(true).
/// </remarks>
/// <exception cref="SynchronizationLockException">
/// Thread ownership tracking is enabled, and the current thread is not the owner of this lock.
/// publish the exit operation to other threads.
/// </param>
/// <remarks>
- /// Calling <see cref="Exit(
Boolean)"/> with the <paramref name="useMemoryBarrier"/> argument set to
+ /// Calling <see cref="Exit(
bool)"/> with the <paramref name="useMemoryBarrier"/> argument set to
/// true will improve the fairness of the lock at the expense of some performance. The default <see
/// cref="Enter"/>
/// overload behaves as if specifying true for <paramref name="useMemoryBarrier"/>.
}
- public virtual void Send(SendOrPostCallback d, Object state)
+ public virtual void Send(SendOrPostCallback d, object state)
{
d(state);
}
- public virtual void Post(SendOrPostCallback d, Object state)
+ public virtual void Post(SendOrPostCallback d, object state)
{
ThreadPool.QueueUserWorkItem(s => s.d(s.state), (d, state), preferLocal: false);
}
//COM Interface GUID {50850B26-267E-451B-A890-AB6A370245EE}
Guid guid = new Guid(0x50850B26, 0x267E, 0x451B, 0xA8, 0x90, 0XAB, 0x6A, 0x37, 0x02, 0x45, 0xEE);
- Object factory = null;
+ object factory = null;
try
{
}
}
- private static void TracingStatusChangedHandler(Object sender, WFD.TracingStatusChangedEventArgs args)
+ private static void TracingStatusChangedHandler(object sender, WFD.TracingStatusChangedEventArgs args)
{
if (args.Enabled)
f_LoggingOn |= Loggers.CausalityTracer;
/// However, unless creation and scheduling must be separated, StartNew is the recommended approach
/// for both simplicity and performance.
/// </remarks>
- public Task<TResult> StartNew(Func<Object, TResult> function, Object state)
+ public Task<TResult> StartNew(Func<object, TResult> function, object state)
{
Task currTask = Task.InternalCurrent;
return Task<TResult>.StartNew(currTask, function, state, m_defaultCancellationToken,
/// However, unless creation and scheduling must be separated, StartNew is the recommended approach
/// for both simplicity and performance.
/// </remarks>
- public Task<TResult> StartNew(Func<Object, TResult> function, Object state, CancellationToken cancellationToken)
+ public Task<TResult> StartNew(Func<object, TResult> function, object state, CancellationToken cancellationToken)
{
Task currTask = Task.InternalCurrent;
return Task<TResult>.StartNew(currTask, function, state, cancellationToken,
/// However, unless creation and scheduling must be separated, StartNew is the recommended approach
/// for both simplicity and performance.
/// </remarks>
- public Task<TResult> StartNew(Func<Object, TResult> function, Object state, TaskCreationOptions creationOptions)
+ public Task<TResult> StartNew(Func<object, TResult> function, object state, TaskCreationOptions creationOptions)
{
Task currTask = Task.InternalCurrent;
return Task<TResult>.StartNew(currTask, function, state, m_defaultCancellationToken,
/// However, unless creation and scheduling must be separated, StartNew is the recommended approach
/// for both simplicity and performance.
/// </remarks>
- public Task<TResult> StartNew(Func<Object, TResult> function, Object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
+ public Task<TResult> StartNew(Func<object, TResult> function, object state, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)
{
return Task<TResult>.StartNew(Task.InternalCurrentIfAttached(creationOptions), function, state, cancellationToken,
creationOptions, InternalTaskOptions.None, scheduler);
/// <summary>The initial size to use for segments (in number of elements).</summary>
private const int INIT_SEGMENT_SIZE = 32; // must be a power of 2
/// <summary>The maximum size to use for segments (in number of elements).</summary>
- private const int MAX_SEGMENT_SIZE = 0x1000000; // this could be made as large as Int32.MaxValue / 2
+ private const int MAX_SEGMENT_SIZE = 0x1000000; // this could be made as large as int.MaxValue / 2
/// <summary>The head of the linked list of segments.</summary>
private volatile Segment m_head;
Debug.Assert(INIT_SEGMENT_SIZE > 0, "Initial segment size must be > 0.");
Debug.Assert((INIT_SEGMENT_SIZE & (INIT_SEGMENT_SIZE - 1)) == 0, "Initial segment size must be a power of 2");
Debug.Assert(INIT_SEGMENT_SIZE <= MAX_SEGMENT_SIZE, "Initial segment size should be <= maximum.");
- Debug.Assert(MAX_SEGMENT_SIZE < Int32.MaxValue / 2, "Max segment size * 2 must be < Int32.MaxValue, or else overflow could occur.");
+ Debug.Assert(MAX_SEGMENT_SIZE < int.MaxValue / 2, "Max segment size * 2 must be < int.MaxValue, or else overflow could occur.");
// Initialize the queue
m_head = m_tail = new Segment(INIT_SEGMENT_SIZE);
unsafe
{
EventData* eventPayload = stackalloc EventData[4];
- Int32 isExceptionalInt = IsExceptional ? 1 : 0;
+ int isExceptionalInt = IsExceptional ? 1 : 0;
eventPayload[0].Size = sizeof(int);
eventPayload[0].DataPointer = ((IntPtr)(&OriginatingTaskSchedulerID));
eventPayload[0].Reserved = 0;
// This dictonary relates the task id, from an operation id located in the Async Causality log to the actual
// task. This is to be used by the debugger ONLY. Task in this dictionary represent current active tasks.
private static readonly Dictionary<int, Task> s_currentActiveTasks = new Dictionary<int, Task>();
- private static readonly Object s_activeTasksLock = new Object();
+ private static readonly object s_activeTasksLock = new object();
// These methods are a way to access the dictionary both from this class and for other classes that also
// activate dummy tasks. Specifically the AsyncTaskMethodBuilder and AsyncTaskMethodBuilder<>
// Static delegate to be used as a cancellation callback on unstarted tasks that have a valid cancellation token.
// This is necessary to transition them into canceled state if their cancellation token is signalled while they are still not queued
- private readonly static Action<Object> s_taskCancelCallback = new Action<Object>(TaskCancelCallback);
- private static void TaskCancelCallback(Object o)
+ private readonly static Action<object> s_taskCancelCallback = new Action<object>(TaskCancelCallback);
+ private static void TaskCancelCallback(object o)
{
var targetTask = o as Task;
if (targetTask == null)
/// <exception cref="T:System.ArgumentOutOfRangeException">
/// <paramref name="timeout"/> is a negative number other than -1 milliseconds, which represents an
/// infinite time-out -or- timeout is greater than
- /// <see cref="System.Int32.MaxValue"/>.
+ /// <see cref="System.int.MaxValue"/>.
/// </exception>
public bool Wait(TimeSpan timeout)
{
long totalMilliseconds = (long)timeout.TotalMilliseconds;
- if (totalMilliseconds < -1 || totalMilliseconds > Int32.MaxValue)
+ if (totalMilliseconds < -1 || totalMilliseconds > int.MaxValue)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.timeout);
}
/// <exception cref="T:System.ArgumentNullException">
/// The <paramref name="continuationAction"/> argument is null.
/// </exception>
- public Task ContinueWith(Action<Task, Object> continuationAction, Object state)
+ public Task ContinueWith(Action<Task, object> continuationAction, object state)
{
return ContinueWith(continuationAction, state, TaskScheduler.Current, default, TaskContinuationOptions.None);
}
/// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
/// has already been disposed.
/// </exception>
- public Task ContinueWith(Action<Task, Object> continuationAction, Object state, CancellationToken cancellationToken)
+ public Task ContinueWith(Action<Task, object> continuationAction, object state, CancellationToken cancellationToken)
{
return ContinueWith(continuationAction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
}
/// <exception cref="T:System.ArgumentNullException">
/// The <paramref name="scheduler"/> argument is null.
/// </exception>
- public Task ContinueWith(Action<Task, Object> continuationAction, Object state, TaskScheduler scheduler)
+ public Task ContinueWith(Action<Task, object> continuationAction, object state, TaskScheduler scheduler)
{
return ContinueWith(continuationAction, state, scheduler, default, TaskContinuationOptions.None);
}
/// The <paramref name="continuationOptions"/> argument specifies an invalid value for <see
/// cref="T:System.Threading.Tasks.TaskContinuationOptions">TaskContinuationOptions</see>.
/// </exception>
- public Task ContinueWith(Action<Task, Object> continuationAction, Object state, TaskContinuationOptions continuationOptions)
+ public Task ContinueWith(Action<Task, object> continuationAction, object state, TaskContinuationOptions continuationOptions)
{
return ContinueWith(continuationAction, state, TaskScheduler.Current, default, continuationOptions);
}
/// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
/// has already been disposed.
/// </exception>
- public Task ContinueWith(Action<Task, Object> continuationAction, Object state, CancellationToken cancellationToken,
+ public Task ContinueWith(Action<Task, object> continuationAction, object state, CancellationToken cancellationToken,
TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
{
return ContinueWith(continuationAction, state, scheduler, cancellationToken, continuationOptions);
}
// Same as the above overload, just with a stack mark parameter.
- private Task ContinueWith(Action<Task, Object> continuationAction, Object state, TaskScheduler scheduler,
+ private Task ContinueWith(Action<Task, object> continuationAction, object state, TaskScheduler scheduler,
CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
{
// Throw on continuation with null action
/// <exception cref="T:System.ArgumentNullException">
/// The <paramref name="continuationFunction"/> argument is null.
/// </exception>
- public Task<TResult> ContinueWith<TResult>(Func<Task, Object, TResult> continuationFunction, Object state)
+ public Task<TResult> ContinueWith<TResult>(Func<Task, object, TResult> continuationFunction, object state)
{
return ContinueWith<TResult>(continuationFunction, state, TaskScheduler.Current, default,
TaskContinuationOptions.None);
/// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
/// has already been disposed.
/// </exception>
- public Task<TResult> ContinueWith<TResult>(Func<Task, Object, TResult> continuationFunction, Object state, CancellationToken cancellationToken)
+ public Task<TResult> ContinueWith<TResult>(Func<Task, object, TResult> continuationFunction, object state, CancellationToken cancellationToken)
{
return ContinueWith<TResult>(continuationFunction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
}
/// <exception cref="T:System.ArgumentNullException">
/// The <paramref name="scheduler"/> argument is null.
/// </exception>
- public Task<TResult> ContinueWith<TResult>(Func<Task, Object, TResult> continuationFunction, Object state, TaskScheduler scheduler)
+ public Task<TResult> ContinueWith<TResult>(Func<Task, object, TResult> continuationFunction, object state, TaskScheduler scheduler)
{
return ContinueWith<TResult>(continuationFunction, state, scheduler, default, TaskContinuationOptions.None);
}
/// The <paramref name="continuationOptions"/> argument specifies an invalid value for <see
/// cref="T:System.Threading.Tasks.TaskContinuationOptions">TaskContinuationOptions</see>.
/// </exception>
- public Task<TResult> ContinueWith<TResult>(Func<Task, Object, TResult> continuationFunction, Object state, TaskContinuationOptions continuationOptions)
+ public Task<TResult> ContinueWith<TResult>(Func<Task, object, TResult> continuationFunction, object state, TaskContinuationOptions continuationOptions)
{
return ContinueWith<TResult>(continuationFunction, state, TaskScheduler.Current, default, continuationOptions);
}
/// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
/// has already been disposed.
/// </exception>
- public Task<TResult> ContinueWith<TResult>(Func<Task, Object, TResult> continuationFunction, Object state, CancellationToken cancellationToken,
+ public Task<TResult> ContinueWith<TResult>(Func<Task, object, TResult> continuationFunction, object state, CancellationToken cancellationToken,
TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
{
return ContinueWith<TResult>(continuationFunction, state, scheduler, cancellationToken, continuationOptions);
}
// Same as the above overload, just with a stack mark parameter.
- private Task<TResult> ContinueWith<TResult>(Func<Task, Object, TResult> continuationFunction, Object state, TaskScheduler scheduler,
+ private Task<TResult> ContinueWith<TResult>(Func<Task, object, TResult> continuationFunction, object state, TaskScheduler scheduler,
CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
{
// Throw on continuation with null function
/// <exception cref="T:System.ArgumentOutOfRangeException">
/// <paramref name="timeout"/> is a negative number other than -1 milliseconds, which represents an
/// infinite time-out -or- timeout is greater than
- /// <see cref="System.Int32.MaxValue"/>.
+ /// <see cref="System.int.MaxValue"/>.
/// </exception>
[MethodImpl(MethodImplOptions.NoOptimization)] // this is needed for the parallel debugger
public static bool WaitAll(Task[] tasks, TimeSpan timeout)
{
long totalMilliseconds = (long)timeout.TotalMilliseconds;
- if (totalMilliseconds < -1 || totalMilliseconds > Int32.MaxValue)
+ if (totalMilliseconds < -1 || totalMilliseconds > int.MaxValue)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.timeout);
}
/// <exception cref="T:System.ArgumentOutOfRangeException">
/// <paramref name="timeout"/> is a negative number other than -1 milliseconds, which represents an
/// infinite time-out -or- timeout is greater than
- /// <see cref="System.Int32.MaxValue"/>.
+ /// <see cref="System.int.MaxValue"/>.
/// </exception>
[MethodImpl(MethodImplOptions.NoOptimization)] // this is needed for the parallel debugger
public static int WaitAny(Task[] tasks, TimeSpan timeout)
{
long totalMilliseconds = (long)timeout.TotalMilliseconds;
- if (totalMilliseconds < -1 || totalMilliseconds > Int32.MaxValue)
+ if (totalMilliseconds < -1 || totalMilliseconds > int.MaxValue)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.timeout);
}
/// <param name="delay">The time span to wait before completing the returned Task</param>
/// <returns>A Task that represents the time delay</returns>
/// <exception cref="T:System.ArgumentOutOfRangeException">
- /// The <paramref name="delay"/> is less than -1 or greater than Int32.MaxValue.
+ /// The <paramref name="delay"/> is less than -1 or greater than int.MaxValue.
/// </exception>
/// <remarks>
/// After the specified time delay, the Task is completed in RanToCompletion state.
/// <param name="cancellationToken">The cancellation token that will be checked prior to completing the returned Task</param>
/// <returns>A Task that represents the time delay</returns>
/// <exception cref="T:System.ArgumentOutOfRangeException">
- /// The <paramref name="delay"/> is less than -1 or greater than Int32.MaxValue.
+ /// The <paramref name="delay"/> is less than -1 or greater than int.MaxValue.
/// </exception>
/// <exception cref="T:System.ObjectDisposedException">
/// The provided <paramref name="cancellationToken"/> has already been disposed.
public static Task Delay(TimeSpan delay, CancellationToken cancellationToken)
{
long totalMilliseconds = (long)delay.TotalMilliseconds;
- if (totalMilliseconds < -1 || totalMilliseconds > Int32.MaxValue)
+ if (totalMilliseconds < -1 || totalMilliseconds > int.MaxValue)
{
ThrowHelper.ThrowArgumentOutOfRangeException(ExceptionArgument.delay, ExceptionResource.Task_Delay_InvalidDelay);
}
/// However, unless creation and scheduling must be separated, StartNew is the recommended approach
/// for both simplicity and performance.
/// </remarks>
- public Task StartNew(Action<Object> action, Object state)
+ public Task StartNew(Action<object> action, object state)
{
Task currTask = Task.InternalCurrent;
return Task.InternalStartNew(currTask, action, state, m_defaultCancellationToken, GetDefaultScheduler(currTask),
/// However, unless creation and scheduling must be separated, StartNew is the recommended approach
/// for both simplicity and performance.
/// </remarks>
- public Task StartNew(Action<Object> action, Object state, CancellationToken cancellationToken)
+ public Task StartNew(Action<object> action, object state, CancellationToken cancellationToken)
{
Task currTask = Task.InternalCurrent;
return Task.InternalStartNew(currTask, action, state, cancellationToken, GetDefaultScheduler(currTask),
/// However, unless creation and scheduling must be separated, StartNew is the recommended approach
/// for both simplicity and performance.
/// </remarks>
- public Task StartNew(Action<Object> action, Object state, TaskCreationOptions creationOptions)
+ public Task StartNew(Action<object> action, object state, TaskCreationOptions creationOptions)
{
Task currTask = Task.InternalCurrent;
return Task.InternalStartNew(currTask, action, state, m_defaultCancellationToken, GetDefaultScheduler(currTask),
/// However, unless creation and scheduling must be separated, StartNew is the recommended approach
/// for both simplicity and performance.
/// </remarks>
- public Task StartNew(Action<Object> action, Object state, CancellationToken cancellationToken,
+ public Task StartNew(Action<object> action, object state, CancellationToken cancellationToken,
TaskCreationOptions creationOptions, TaskScheduler scheduler)
{
return Task.InternalStartNew(
/// However, unless creation and scheduling must be separated, StartNew is the recommended approach
/// for both simplicity and performance.
/// </remarks>
- public Task<TResult> StartNew<TResult>(Func<Object, TResult> function, Object state)
+ public Task<TResult> StartNew<TResult>(Func<object, TResult> function, object state)
{
Task currTask = Task.InternalCurrent;
return Task<TResult>.StartNew(currTask, function, state, m_defaultCancellationToken,
/// However, unless creation and scheduling must be separated, StartNew is the recommended approach
/// for both simplicity and performance.
/// </remarks>
- public Task<TResult> StartNew<TResult>(Func<Object, TResult> function, Object state, CancellationToken cancellationToken)
+ public Task<TResult> StartNew<TResult>(Func<object, TResult> function, object state, CancellationToken cancellationToken)
{
Task currTask = Task.InternalCurrent;
return Task<TResult>.StartNew(currTask, function, state, cancellationToken,
/// However, unless creation and scheduling must be separated, StartNew is the recommended approach
/// for both simplicity and performance.
/// </remarks>
- public Task<TResult> StartNew<TResult>(Func<Object, TResult> function, Object state, TaskCreationOptions creationOptions)
+ public Task<TResult> StartNew<TResult>(Func<object, TResult> function, object state, TaskCreationOptions creationOptions)
{
Task currTask = Task.InternalCurrent;
return Task<TResult>.StartNew(currTask, function, state, m_defaultCancellationToken,
/// However, unless creation and scheduling must be separated, StartNew is the recommended approach
/// for both simplicity and performance.
/// </remarks>
- public Task<TResult> StartNew<TResult>(Func<Object, TResult> function, Object state, CancellationToken cancellationToken,
+ public Task<TResult> StartNew<TResult>(Func<object, TResult> function, object state, CancellationToken cancellationToken,
TaskCreationOptions creationOptions, TaskScheduler scheduler)
{
return Task<TResult>.StartNew(
/// Indicates the maximum concurrency level this
/// <see cref="TaskScheduler"/> is able to support.
/// </summary>
- public virtual Int32 MaximumConcurrencyLevel
+ public virtual int MaximumConcurrencyLevel
{
get
{
- return Int32.MaxValue;
+ return int.MaxValue;
}
}
/// <summary>
/// Gets the unique ID for this <see cref="TaskScheduler"/>.
/// </summary>
- public Int32 Id
+ public int Id
{
get
{
}
// returns the scheduler�s Id
- public Int32 Id
+ public int Id
{
get { return m_taskScheduler.Id; }
}
/// By default it returns 1, because a <see cref="T:System.Threading.SynchronizationContext"/> based
/// scheduler only supports execution on a single thread.
/// </summary>
- public override Int32 MaximumConcurrencyLevel
+ public override int MaximumConcurrencyLevel
{
get
{
/// <exception cref="T:System.ArgumentNullException">
/// The <paramref name="continuationAction"/> argument is null.
/// </exception>
- public Task ContinueWith(Action<Task<TResult>, Object> continuationAction, Object state)
+ public Task ContinueWith(Action<Task<TResult>, object> continuationAction, object state)
{
return ContinueWith(continuationAction, state, TaskScheduler.Current, default, TaskContinuationOptions.None);
}
/// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
/// has already been disposed.
/// </exception>
- public Task ContinueWith(Action<Task<TResult>, Object> continuationAction, Object state, CancellationToken cancellationToken)
+ public Task ContinueWith(Action<Task<TResult>, object> continuationAction, object state, CancellationToken cancellationToken)
{
return ContinueWith(continuationAction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
}
/// <exception cref="T:System.ArgumentNullException">
/// The <paramref name="scheduler"/> argument is null.
/// </exception>
- public Task ContinueWith(Action<Task<TResult>, Object> continuationAction, Object state, TaskScheduler scheduler)
+ public Task ContinueWith(Action<Task<TResult>, object> continuationAction, object state, TaskScheduler scheduler)
{
return ContinueWith(continuationAction, state, scheduler, default, TaskContinuationOptions.None);
}
/// The <paramref name="continuationOptions"/> argument specifies an invalid value for <see
/// cref="T:System.Threading.Tasks.TaskContinuationOptions">TaskContinuationOptions</see>.
/// </exception>
- public Task ContinueWith(Action<Task<TResult>, Object> continuationAction, Object state, TaskContinuationOptions continuationOptions)
+ public Task ContinueWith(Action<Task<TResult>, object> continuationAction, object state, TaskContinuationOptions continuationOptions)
{
return ContinueWith(continuationAction, state, TaskScheduler.Current, default, continuationOptions);
}
/// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
/// has already been disposed.
/// </exception>
- public Task ContinueWith(Action<Task<TResult>, Object> continuationAction, Object state, CancellationToken cancellationToken,
+ public Task ContinueWith(Action<Task<TResult>, object> continuationAction, object state, CancellationToken cancellationToken,
TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
{
return ContinueWith(continuationAction, state, scheduler, cancellationToken, continuationOptions);
}
// Same as the above overload, only with a stack mark.
- internal Task ContinueWith(Action<Task<TResult>, Object> continuationAction, Object state, TaskScheduler scheduler, CancellationToken cancellationToken,
+ internal Task ContinueWith(Action<Task<TResult>, object> continuationAction, object state, TaskScheduler scheduler, CancellationToken cancellationToken,
TaskContinuationOptions continuationOptions)
{
if (continuationAction == null)
/// <exception cref="T:System.ArgumentNullException">
/// The <paramref name="continuationFunction"/> argument is null.
/// </exception>
- public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult> continuationFunction, Object state)
+ public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, object, TNewResult> continuationFunction, object state)
{
return ContinueWith<TNewResult>(continuationFunction, state, TaskScheduler.Current, default, TaskContinuationOptions.None);
}
/// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
/// has already been disposed.
/// </exception>
- public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult> continuationFunction, Object state,
+ public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, object, TNewResult> continuationFunction, object state,
CancellationToken cancellationToken)
{
return ContinueWith<TNewResult>(continuationFunction, state, TaskScheduler.Current, cancellationToken, TaskContinuationOptions.None);
/// <exception cref="T:System.ArgumentNullException">
/// The <paramref name="scheduler"/> argument is null.
/// </exception>
- public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult> continuationFunction, Object state,
+ public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, object, TNewResult> continuationFunction, object state,
TaskScheduler scheduler)
{
return ContinueWith<TNewResult>(continuationFunction, state, scheduler, default, TaskContinuationOptions.None);
/// The <paramref name="continuationOptions"/> argument specifies an invalid value for <see
/// cref="T:System.Threading.Tasks.TaskContinuationOptions">TaskContinuationOptions</see>.
/// </exception>
- public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult> continuationFunction, Object state,
+ public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, object, TNewResult> continuationFunction, object state,
TaskContinuationOptions continuationOptions)
{
return ContinueWith<TNewResult>(continuationFunction, state, TaskScheduler.Current, default, continuationOptions);
/// <exception cref="T:System.ObjectDisposedException">The provided <see cref="System.Threading.CancellationToken">CancellationToken</see>
/// has already been disposed.
/// </exception>
- public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult> continuationFunction, Object state,
+ public Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, object, TNewResult> continuationFunction, object state,
CancellationToken cancellationToken, TaskContinuationOptions continuationOptions, TaskScheduler scheduler)
{
return ContinueWith<TNewResult>(continuationFunction, state, scheduler, cancellationToken, continuationOptions);
}
// Same as the above overload, just with a stack mark.
- internal Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, Object, TNewResult> continuationFunction, Object state,
+ internal Task<TNewResult> ContinueWith<TNewResult>(Func<Task<TResult>, object, TNewResult> continuationFunction, object state,
TaskScheduler scheduler, CancellationToken cancellationToken, TaskContinuationOptions continuationOptions)
{
if (continuationFunction == null)
using System.Runtime.Versioning;
using System.Diagnostics;
- internal delegate Object InternalCrossContextDelegate(Object[] args);
+ internal delegate object InternalCrossContextDelegate(object[] args);
internal class ThreadHelper
{
private Delegate _start;
- private Object _startArg = null;
+ private object _startArg = null;
private ExecutionContext _executionContext = null;
internal ThreadHelper(Delegate start)
{
internal static ContextCallback _ccb = new ContextCallback(ThreadStart_Context);
- private static void ThreadStart_Context(Object state)
+ private static void ThreadStart_Context(object state)
{
ThreadHelper t = (ThreadHelper)state;
if (t._start is ThreadStart)
ExecutionContext context = _executionContext;
if (context != null)
{
- ExecutionContext.RunInternal(context, _ccb, (Object)this);
+ ExecutionContext.RunInternal(context, _ccb, (object)this);
}
else
{
ExecutionContext context = _executionContext;
if (context != null)
{
- ExecutionContext.RunInternal(context, _ccb, (Object)this);
+ ExecutionContext.RunInternal(context, _ccb, (object)this);
}
else
{
private ExecutionContext m_ExecutionContext; // this call context follows the logical thread
private SynchronizationContext m_SynchronizationContext; // On CoreCLR, this is maintained separately from ExecutionContext
- private String m_Name;
+ private string m_Name;
private Delegate m_Delegate; // Delegate
- private Object m_ThreadStartArg;
+ private object m_ThreadStartArg;
/*=========================================================================
** The base implementation of Thread is all native. The following fields
public static void Sleep(TimeSpan timeout)
{
long tm = (long)timeout.TotalMilliseconds;
- if (tm < -1 || tm > (long)Int32.MaxValue)
+ if (tm < -1 || tm > (long)int.MaxValue)
throw new ArgumentOutOfRangeException(nameof(timeout), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
Sleep((int)tm);
}
// Retrieves the name of the thread.
//
- public new String Name
+ public new string Name
{
get
{
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private static extern void InformThreadNameChange(ThreadHandle t, String name, int len);
+ private static extern void InformThreadNameChange(ThreadHandle t, string name, int len);
} // End of class Thread
}
}
- public delegate void WaitCallback(Object state);
+ public delegate void WaitCallback(object state);
- public delegate void WaitOrTimerCallback(Object state, bool timedOut); // signaled or timed out
+ public delegate void WaitOrTimerCallback(object state, bool timedOut); // signaled or timed out
//
// This type is necessary because VS 2010's debugger looks for a method named _ThreadPoolWaitCallbacck.PerformWaitCallback
{
private WaitOrTimerCallback _waitOrTimerCallback;
private ExecutionContext _executionContext;
- private Object _state;
+ private object _state;
private static readonly ContextCallback _ccbt = new ContextCallback(WaitOrTimerCallback_Context_t);
private static readonly ContextCallback _ccbf = new ContextCallback(WaitOrTimerCallback_Context_f);
- internal _ThreadPoolWaitOrTimerCallback(WaitOrTimerCallback waitOrTimerCallback, Object state, bool compressStack)
+ internal _ThreadPoolWaitOrTimerCallback(WaitOrTimerCallback waitOrTimerCallback, object state, bool compressStack)
{
_waitOrTimerCallback = waitOrTimerCallback;
_state = state;
}
}
- private static void WaitOrTimerCallback_Context_t(Object state) =>
+ private static void WaitOrTimerCallback_Context_t(object state) =>
WaitOrTimerCallback_Context(state, timedOut: true);
- private static void WaitOrTimerCallback_Context_f(Object state) =>
+ private static void WaitOrTimerCallback_Context_f(object state) =>
WaitOrTimerCallback_Context(state, timedOut: false);
- private static void WaitOrTimerCallback_Context(Object state, bool timedOut)
+ private static void WaitOrTimerCallback_Context(object state, bool timedOut)
{
_ThreadPoolWaitOrTimerCallback helper = (_ThreadPoolWaitOrTimerCallback)state;
helper._waitOrTimerCallback(helper._state, timedOut);
}
// call back helper
- internal static void PerformWaitOrTimerCallback(Object state, bool timedOut)
+ internal static void PerformWaitOrTimerCallback(object state, bool timedOut)
{
_ThreadPoolWaitOrTimerCallback helper = (_ThreadPoolWaitOrTimerCallback)state;
Debug.Assert(helper != null, "Null state passed to PerformWaitOrTimerCallback!");
public static RegisteredWaitHandle RegisterWaitForSingleObject( // throws RegisterWaitException
WaitHandle waitObject,
WaitOrTimerCallback callBack,
- Object state,
+ object state,
uint millisecondsTimeOutInterval,
bool executeOnlyOnce // NOTE: we do not allow other options that allow the callback to be queued as an APC
)
public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject( // throws RegisterWaitException
WaitHandle waitObject,
WaitOrTimerCallback callBack,
- Object state,
+ object state,
uint millisecondsTimeOutInterval,
bool executeOnlyOnce // NOTE: we do not allow other options that allow the callback to be queued as an APC
)
private static RegisteredWaitHandle RegisterWaitForSingleObject( // throws RegisterWaitException
WaitHandle waitObject,
WaitOrTimerCallback callBack,
- Object state,
+ object state,
uint millisecondsTimeOutInterval,
bool executeOnlyOnce, // NOTE: we do not allow other options that allow the callback to be queued as an APC
bool compressStack
if (callBack != null)
{
_ThreadPoolWaitOrTimerCallback callBackHelper = new _ThreadPoolWaitOrTimerCallback(callBack, state, compressStack);
- state = (Object)callBackHelper;
+ state = (object)callBackHelper;
// call SetWaitObject before native call so that waitObject won't be closed before threadpoolmgr registration
// this could occur if callback were to fire before SetWaitObject does its addref
registeredWaitHandle.SetWaitObject(waitObject);
public static RegisteredWaitHandle RegisterWaitForSingleObject( // throws RegisterWaitException
WaitHandle waitObject,
WaitOrTimerCallback callBack,
- Object state,
+ object state,
int millisecondsTimeOutInterval,
bool executeOnlyOnce // NOTE: we do not allow other options that allow the callback to be queued as an APC
)
{
if (millisecondsTimeOutInterval < -1)
throw new ArgumentOutOfRangeException(nameof(millisecondsTimeOutInterval), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
- return RegisterWaitForSingleObject(waitObject, callBack, state, (UInt32)millisecondsTimeOutInterval, executeOnlyOnce, true);
+ return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)millisecondsTimeOutInterval, executeOnlyOnce, true);
}
public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject( // throws RegisterWaitException
WaitHandle waitObject,
WaitOrTimerCallback callBack,
- Object state,
+ object state,
int millisecondsTimeOutInterval,
bool executeOnlyOnce // NOTE: we do not allow other options that allow the callback to be queued as an APC
)
{
if (millisecondsTimeOutInterval < -1)
throw new ArgumentOutOfRangeException(nameof(millisecondsTimeOutInterval), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
- return RegisterWaitForSingleObject(waitObject, callBack, state, (UInt32)millisecondsTimeOutInterval, executeOnlyOnce, false);
+ return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)millisecondsTimeOutInterval, executeOnlyOnce, false);
}
public static RegisteredWaitHandle RegisterWaitForSingleObject( // throws RegisterWaitException
WaitHandle waitObject,
WaitOrTimerCallback callBack,
- Object state,
+ object state,
long millisecondsTimeOutInterval,
bool executeOnlyOnce // NOTE: we do not allow other options that allow the callback to be queued as an APC
)
{
if (millisecondsTimeOutInterval < -1)
throw new ArgumentOutOfRangeException(nameof(millisecondsTimeOutInterval), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
- return RegisterWaitForSingleObject(waitObject, callBack, state, (UInt32)millisecondsTimeOutInterval, executeOnlyOnce, true);
+ return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)millisecondsTimeOutInterval, executeOnlyOnce, true);
}
public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject( // throws RegisterWaitException
WaitHandle waitObject,
WaitOrTimerCallback callBack,
- Object state,
+ object state,
long millisecondsTimeOutInterval,
bool executeOnlyOnce // NOTE: we do not allow other options that allow the callback to be queued as an APC
)
{
if (millisecondsTimeOutInterval < -1)
throw new ArgumentOutOfRangeException(nameof(millisecondsTimeOutInterval), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
- return RegisterWaitForSingleObject(waitObject, callBack, state, (UInt32)millisecondsTimeOutInterval, executeOnlyOnce, false);
+ return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)millisecondsTimeOutInterval, executeOnlyOnce, false);
}
public static RegisteredWaitHandle RegisterWaitForSingleObject(
WaitHandle waitObject,
WaitOrTimerCallback callBack,
- Object state,
+ object state,
TimeSpan timeout,
bool executeOnlyOnce
)
long tm = (long)timeout.TotalMilliseconds;
if (tm < -1)
throw new ArgumentOutOfRangeException(nameof(timeout), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
- if (tm > (long)Int32.MaxValue)
+ if (tm > (long)int.MaxValue)
throw new ArgumentOutOfRangeException(nameof(timeout), SR.ArgumentOutOfRange_LessEqualToIntegerMaxVal);
- return RegisterWaitForSingleObject(waitObject, callBack, state, (UInt32)tm, executeOnlyOnce, true);
+ return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)tm, executeOnlyOnce, true);
}
public static RegisteredWaitHandle UnsafeRegisterWaitForSingleObject(
WaitHandle waitObject,
WaitOrTimerCallback callBack,
- Object state,
+ object state,
TimeSpan timeout,
bool executeOnlyOnce
)
long tm = (long)timeout.TotalMilliseconds;
if (tm < -1)
throw new ArgumentOutOfRangeException(nameof(timeout), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
- if (tm > (long)Int32.MaxValue)
+ if (tm > (long)int.MaxValue)
throw new ArgumentOutOfRangeException(nameof(timeout), SR.ArgumentOutOfRange_LessEqualToIntegerMaxVal);
- return RegisterWaitForSingleObject(waitObject, callBack, state, (UInt32)tm, executeOnlyOnce, false);
+ return RegisterWaitForSingleObject(waitObject, callBack, state, (uint)tm, executeOnlyOnce, false);
}
public static bool QueueUserWorkItem(WaitCallback callBack) =>
return true;
}
- public static bool UnsafeQueueUserWorkItem(WaitCallback callBack, Object state)
+ public static bool UnsafeQueueUserWorkItem(WaitCallback callBack, object state)
{
if (callBack == null)
{
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private static extern IntPtr RegisterWaitForSingleObjectNative(
WaitHandle waitHandle,
- Object state,
+ object state,
uint timeOutInterval,
bool executeOnlyOnce,
RegisteredWaitHandle registeredWaitHandle
namespace System.Threading
{
- public delegate void TimerCallback(Object state);
+ public delegate void TimerCallback(object state);
//
// TimerQueue maintains a list of active timers in this AppDomain. We use a single native timer, supplied by the VM,
// Info about the user's callback
//
private readonly TimerCallback m_timerCallback;
- private readonly Object m_state;
+ private readonly object m_state;
private readonly ExecutionContext m_executionContext;
public sealed class Timer : MarshalByRefObject, IDisposable
{
- private const UInt32 MAX_SUPPORTED_TIMEOUT = (uint)0xfffffffe;
+ private const uint MAX_SUPPORTED_TIMEOUT = (uint)0xfffffffe;
private TimerHolder m_timer;
public Timer(TimerCallback callback,
- Object state,
+ object state,
int dueTime,
int period)
{
if (period < -1)
throw new ArgumentOutOfRangeException(nameof(period), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
- TimerSetup(callback, state, (UInt32)dueTime, (UInt32)period);
+ TimerSetup(callback, state, (uint)dueTime, (uint)period);
}
public Timer(TimerCallback callback,
- Object state,
+ object state,
TimeSpan dueTime,
TimeSpan period)
{
if (periodTm > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException(nameof(periodTm), SR.ArgumentOutOfRange_PeriodTooLarge);
- TimerSetup(callback, state, (UInt32)dueTm, (UInt32)periodTm);
+ TimerSetup(callback, state, (uint)dueTm, (uint)periodTm);
}
[CLSCompliant(false)]
public Timer(TimerCallback callback,
- Object state,
- UInt32 dueTime,
- UInt32 period)
+ object state,
+ uint dueTime,
+ uint period)
{
TimerSetup(callback, state, dueTime, period);
}
public Timer(TimerCallback callback,
- Object state,
+ object state,
long dueTime,
long period)
{
throw new ArgumentOutOfRangeException(nameof(dueTime), SR.ArgumentOutOfRange_TimeoutTooLarge);
if (period > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException(nameof(period), SR.ArgumentOutOfRange_PeriodTooLarge);
- TimerSetup(callback, state, (UInt32)dueTime, (UInt32)period);
+ TimerSetup(callback, state, (uint)dueTime, (uint)period);
}
public Timer(TimerCallback callback)
// for a timer to be fired before the returned value is assigned to the variable,
// potentially causing the callback to reference a bogus value (if passing the timer to the callback).
- TimerSetup(callback, this, (UInt32)dueTime, (UInt32)period);
+ TimerSetup(callback, this, (uint)dueTime, (uint)period);
}
private void TimerSetup(TimerCallback callback,
- Object state,
- UInt32 dueTime,
- UInt32 period)
+ object state,
+ uint dueTime,
+ uint period)
{
if (callback == null)
throw new ArgumentNullException(nameof(TimerCallback));
if (period < -1)
throw new ArgumentOutOfRangeException(nameof(period), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
- return m_timer.m_timer.Change((UInt32)dueTime, (UInt32)period);
+ return m_timer.m_timer.Change((uint)dueTime, (uint)period);
}
public bool Change(TimeSpan dueTime, TimeSpan period)
}
[CLSCompliant(false)]
- public bool Change(UInt32 dueTime, UInt32 period)
+ public bool Change(uint dueTime, uint period)
{
return m_timer.m_timer.Change(dueTime, period);
}
if (period > MAX_SUPPORTED_TIMEOUT)
throw new ArgumentOutOfRangeException(nameof(period), SR.ArgumentOutOfRange_PeriodTooLarge);
- return m_timer.m_timer.Change((UInt32)dueTime, (UInt32)period);
+ return m_timer.m_timer.Change((uint)dueTime, (uint)period);
}
public bool Dispose(WaitHandle notifyObject)
public virtual bool WaitOne(TimeSpan timeout, bool exitContext)
{
long tm = (long)timeout.TotalMilliseconds;
- if (-1 > tm || (long)Int32.MaxValue < tm)
+ if (-1 > tm || (long)int.MaxValue < tm)
{
throw new ArgumentOutOfRangeException(nameof(timeout), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
}
bool exitContext)
{
long tm = (long)timeout.TotalMilliseconds;
- if (-1 > tm || (long)Int32.MaxValue < tm)
+ if (-1 > tm || (long)int.MaxValue < tm)
{
throw new ArgumentOutOfRangeException(nameof(timeout), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
}
bool exitContext)
{
long tm = (long)timeout.TotalMilliseconds;
- if (-1 > tm || (long)Int32.MaxValue < tm)
+ if (-1 > tm || (long)int.MaxValue < tm)
{
throw new ArgumentOutOfRangeException(nameof(timeout), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
}
bool exitContext)
{
long tm = (long)timeout.TotalMilliseconds;
- if (-1 > tm || (long)Int32.MaxValue < tm)
+ if (-1 > tm || (long)int.MaxValue < tm)
{
throw new ArgumentOutOfRangeException(nameof(timeout), SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
}
internal static void ThrowNotSupportedExceptionIfNonNumericType<T>()
{
- if (typeof(T) != typeof(Byte) && typeof(T) != typeof(SByte) &&
- typeof(T) != typeof(Int16) && typeof(T) != typeof(UInt16) &&
- typeof(T) != typeof(Int32) && typeof(T) != typeof(UInt32) &&
- typeof(T) != typeof(Int64) && typeof(T) != typeof(UInt64) &&
- typeof(T) != typeof(Single) && typeof(T) != typeof(Double))
+ if (typeof(T) != typeof(byte) && typeof(T) != typeof(sbyte) &&
+ typeof(T) != typeof(short) && typeof(T) != typeof(ushort) &&
+ typeof(T) != typeof(int) && typeof(T) != typeof(uint) &&
+ typeof(T) != typeof(long) && typeof(T) != typeof(ulong) &&
+ typeof(T) != typeof(float) && typeof(T) != typeof(double))
{
throw new NotSupportedException(SR.Arg_TypeNotSupported);
}
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
- public static Type GetType(String typeName, bool throwOnError, bool ignoreCase)
+ public static Type GetType(string typeName, bool throwOnError, bool ignoreCase)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeType.GetType(typeName, throwOnError, ignoreCase, false, ref stackMark);
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
- public static Type GetType(String typeName, bool throwOnError)
+ public static Type GetType(string typeName, bool throwOnError)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeType.GetType(typeName, throwOnError, false, false, ref stackMark);
}
[System.Security.DynamicSecurityMethod] // Methods containing StackCrawlMark local var has to be marked DynamicSecurityMethod
- public static Type GetType(String typeName)
+ public static Type GetType(string typeName)
{
StackCrawlMark stackMark = StackCrawlMark.LookForMyCaller;
return RuntimeType.GetType(typeName, false, false, false, ref stackMark);
// param progID: the progID of the class to retrieve
// returns: the class object associated to the progID
////
- public static Type GetTypeFromProgID(String progID, String server, bool throwOnError)
+ public static Type GetTypeFromProgID(string progID, string server, bool throwOnError)
{
return RuntimeType.GetTypeFromProgIDImpl(progID, server, throwOnError);
}
// param CLSID: the CLSID of the class to retrieve
// returns: the class object associated to the CLSID
////
- public static Type GetTypeFromCLSID(Guid clsid, String server, bool throwOnError)
+ public static Type GetTypeFromCLSID(Guid clsid, string server, bool throwOnError)
{
return RuntimeType.GetTypeFromCLSIDImpl(clsid, server, throwOnError);
}
private IntPtr Type;
[CLSCompliant(false)]
- public static TypedReference MakeTypedReference(Object target, FieldInfo[] flds)
+ public static TypedReference MakeTypedReference(object target, FieldInfo[] flds)
{
if (target == null)
throw new ArgumentNullException(nameof(target));
[MethodImplAttribute(MethodImplOptions.InternalCall)]
// reference to TypedReference is banned, so have to pass result as pointer
- private static extern unsafe void InternalMakeTypedReference(void* result, Object target, IntPtr[] flds, RuntimeType lastFieldType);
+ private static extern unsafe void InternalMakeTypedReference(void* result, object target, IntPtr[] flds, RuntimeType lastFieldType);
public override int GetHashCode()
{
return __reftype(this).GetHashCode();
}
- public override bool Equals(Object o)
+ public override bool Equals(object o)
{
throw new NotSupportedException(SR.NotSupported_NYI);
}
- public static unsafe Object ToObject(TypedReference value)
+ public static unsafe object ToObject(TypedReference value)
{
return InternalToObject(&value);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern unsafe Object InternalToObject(void* value);
+ internal static extern unsafe object InternalToObject(void* value);
internal bool IsNull
{
// This may cause the type to be changed.
[CLSCompliant(false)]
- public static unsafe void SetTypedReference(TypedReference target, Object value)
+ public static unsafe void SetTypedReference(TypedReference target, object value)
{
InternalSetTypedReference(&target, value);
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal static extern unsafe void InternalSetTypedReference(void* target, Object value);
+ internal static extern unsafe void InternalSetTypedReference(void* target, object value);
}
}
[System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
public abstract class ValueType
{
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (null == obj)
{
return false;
}
- Object thisObj = (Object)this;
- Object thisResult, thatResult;
+ object thisObj = (object)this;
+ object thisResult, thatResult;
// if there are no GC references in this object we can avoid reflection
// and do a fast memcmp
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern bool CanCompareBits(Object obj);
+ private static extern bool CanCompareBits(object obj);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static extern bool FastEqualsCheck(Object a, Object b);
+ private static extern bool FastEqualsCheck(object a, object b);
/*=================================GetHashCode==================================
**Action: Our algorithm for returning the hashcode is a little bit complex. We look
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal static extern int GetHashCodeOfPtr(IntPtr ptr);
- public override String ToString()
+ public override string ToString()
{
return this.GetType().ToString();
}
{
//Do Not change the order of these fields.
//They are mapped to the native VariantData * data structure.
- private Object m_objref;
+ private object m_objref;
private int m_data1;
private int m_data2;
private int m_flags;
internal static readonly Type[] ClassTypes = {
typeof(System.Empty),
typeof(void),
- typeof(Boolean),
- typeof(Char),
- typeof(SByte),
- typeof(Byte),
- typeof(Int16),
- typeof(UInt16),
- typeof(Int32),
- typeof(UInt32),
- typeof(Int64),
- typeof(UInt64),
- typeof(Single),
- typeof(Double),
- typeof(String),
+ typeof(bool),
+ typeof(char),
+ typeof(sbyte),
+ typeof(byte),
+ typeof(short),
+ typeof(ushort),
+ typeof(int),
+ typeof(uint),
+ typeof(long),
+ typeof(ulong),
+ typeof(float),
+ typeof(double),
+ typeof(string),
typeof(void), // ptr for the moment
typeof(DateTime),
typeof(TimeSpan),
- typeof(Object),
- typeof(Decimal),
- typeof(Object), // Treat enum as Object
+ typeof(object),
+ typeof(decimal),
+ typeof(object), // Treat enum as Object
typeof(System.Reflection.Missing),
typeof(System.DBNull),
};
[MethodImplAttribute(MethodImplOptions.InternalCall)]
internal extern void SetFieldsR8(double val);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- internal extern void SetFieldsObject(Object val);
+ internal extern void SetFieldsObject(object val);
// Use this function instead of an ECALL - saves about 150 clock cycles
// by avoiding the ecall transition and because the JIT inlines this.
// Constructors
//
- internal Variant(int flags, Object or, int data1, int data2)
+ internal Variant(int flags, object or, int data1, int data2)
{
m_flags = flags;
m_objref = or;
{
m_objref = null;
m_flags = CV_BOOLEAN;
- m_data1 = (val) ? Boolean.True : Boolean.False;
+ m_data1 = (val) ? bool.True : bool.False;
m_data2 = 0;
}
m_data2 = (int)(ticks >> 32);
}
- public Variant(Decimal val)
+ public Variant(decimal val)
{
- m_objref = (Object)val;
+ m_objref = (object)val;
m_flags = CV_DECIMAL;
m_data1 = 0;
m_data2 = 0;
}
- public Variant(Object obj)
+ public Variant(object obj)
{
m_data1 = 0;
m_data2 = 0;
return;
}
- if (obj is String)
+ if (obj is string)
{
m_flags = CV_STRING;
m_objref = obj;
else if (obj is ErrorWrapper)
{
vt = VarEnum.VT_ERROR;
- obj = (Object)(((ErrorWrapper)obj).ErrorCode);
+ obj = (object)(((ErrorWrapper)obj).ErrorCode);
Debug.Assert(obj != null, "obj != null");
}
else if (obj is CurrencyWrapper)
{
vt = VarEnum.VT_CY;
- obj = (Object)(((CurrencyWrapper)obj).WrappedObject);
+ obj = (object)(((CurrencyWrapper)obj).WrappedObject);
Debug.Assert(obj != null, "obj != null");
}
else if (obj is BStrWrapper)
{
vt = VarEnum.VT_BSTR;
- obj = (Object)(((BStrWrapper)obj).WrappedObject);
+ obj = (object)(((BStrWrapper)obj).WrappedObject);
}
if (obj != null)
}
}
- public Object ToObject()
+ public object ToObject()
{
switch (CVType)
{
case CV_EMPTY:
return null;
case CV_BOOLEAN:
- return (Object)(m_data1 != 0);
+ return (object)(m_data1 != 0);
case CV_I1:
- return (Object)((sbyte)m_data1);
+ return (object)((sbyte)m_data1);
case CV_U1:
- return (Object)((byte)m_data1);
+ return (object)((byte)m_data1);
case CV_CHAR:
- return (Object)((char)m_data1);
+ return (object)((char)m_data1);
case CV_I2:
- return (Object)((short)m_data1);
+ return (object)((short)m_data1);
case CV_U2:
- return (Object)((ushort)m_data1);
+ return (object)((ushort)m_data1);
case CV_I4:
- return (Object)(m_data1);
+ return (object)(m_data1);
case CV_U4:
- return (Object)((uint)m_data1);
+ return (object)((uint)m_data1);
case CV_I8:
- return (Object)(GetI8FromVar());
+ return (object)(GetI8FromVar());
case CV_U8:
- return (Object)((ulong)GetI8FromVar());
+ return (object)((ulong)GetI8FromVar());
case CV_R4:
- return (Object)(GetR4FromVar());
+ return (object)(GetR4FromVar());
case CV_R8:
- return (Object)(GetR8FromVar());
+ return (object)(GetR8FromVar());
case CV_DATETIME:
return new DateTime(GetI8FromVar());
case CV_TIMESPAN:
// This routine will return an boxed enum.
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private extern Object BoxEnum();
+ private extern object BoxEnum();
// Helper code for marshaling managed objects to VARIANT's (we use
// managed variants as an intermediate type.
- internal static void MarshalHelperConvertObjectToVariant(Object o, ref Variant v)
+ internal static void MarshalHelperConvertObjectToVariant(object o, ref Variant v)
{
IConvertible ic = o as IConvertible;
break;
case TypeCode.Object:
- v = new Variant((Object)o);
+ v = new Variant((object)o);
break;
case TypeCode.DBNull:
// Helper code for marshaling VARIANTS to managed objects (we use
// managed variants as an intermediate type.
- internal static Object MarshalHelperConvertVariantToObject(ref Variant v)
+ internal static object MarshalHelperConvertVariantToObject(ref Variant v)
{
return v.ToObject();
}
// Helper code: on the back propagation path where a VT_BYREF VARIANT*
// is marshaled to a "ref Object", we use this helper to force the
// updated object back to the original type.
- internal static void MarshalHelperCastVariant(Object pValue, int vt, ref Variant v)
+ internal static void MarshalHelperCastVariant(object pValue, int vt, ref Variant v)
{
IConvertible iv = pValue as IConvertible;
if (iv == null)
break;
case 9: /*VT_DISPATCH*/
- v = new Variant(new DispatchWrapper((Object)iv));
+ v = new Variant(new DispatchWrapper((object)iv));
break;
case 10: /*VT_ERROR*/
break;
case 12: /*VT_VARIANT*/
- v = new Variant((Object)iv);
+ v = new Variant((object)iv);
break;
case 13: /*VT_UNKNOWN*/
- v = new Variant(new UnknownWrapper((Object)iv));
+ v = new Variant(new UnknownWrapper((object)iv));
break;
case 14: /*VT_DECIMAL*/
// Creates a new WeakReference that keeps track of target.
// Assumes a Short Weak Reference (ie TrackResurrection is false.)
//
- public WeakReference(Object target)
+ public WeakReference(object target)
: this(target, false)
{
}
//Creates a new WeakReference that keeps track of target.
//
- public WeakReference(Object target, bool trackResurrection)
+ public WeakReference(object target, bool trackResurrection)
{
Create(target, trackResurrection);
}
throw new ArgumentNullException(nameof(info));
}
- Object target = info.GetValue("TrackedObject", typeof(Object)); // Do not rename (binary serialization)
+ object target = info.GetValue("TrackedObject", typeof(object)); // Do not rename (binary serialization)
bool trackResurrection = info.GetBoolean("TrackResurrection"); // Do not rename (binary serialization)
Create(target, trackResurrection);
//Gets the Object stored in the handle if it's accessible.
// Or sets it.
//
- public extern virtual Object Target
+ public extern virtual object Target
{
[MethodImplAttribute(MethodImplOptions.InternalCall)]
get;
{
throw new ArgumentNullException(nameof(info));
}
- info.AddValue("TrackedObject", Target, typeof(Object)); // Do not rename (binary serialization)
+ info.AddValue("TrackedObject", Target, typeof(object)); // Do not rename (binary serialization)
info.AddValue("TrackResurrection", IsTrackResurrection()); // Do not rename (binary serialization)
}
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private extern void Create(Object target, bool trackResurrection);
+ private extern void Create(object target, bool trackResurrection);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
private extern bool IsTrackResurrection();
// This method retrieves the data associated with the specified
// key if any such data exists for the current __ComObject.
//====================================================================
- internal Object GetData(Object key)
+ internal object GetData(object key)
{
- Object data = null;
+ object data = null;
// Synchronize access to the map.
lock (this)
// This method sets the data for the specified key on the current
// __ComObject.
//====================================================================
- internal bool SetData(Object key, Object data)
+ internal bool SetData(object key, object data)
{
bool bAdded = false;
// If the map hasn't been allocated, then there is nothing to do.
if (m_ObjectToDataMap != null)
{
- foreach (Object o in m_ObjectToDataMap.Values)
+ foreach (object o in m_ObjectToDataMap.Values)
{
// Note: the value could be an object[]
// We are fine for now as object[] doesn't implement IDisposable nor derive from __ComObject
// This method is called from within the EE and is used to handle
// calls on methods of event interfaces.
//====================================================================
- internal Object GetEventProvider(RuntimeType t)
+ internal object GetEventProvider(RuntimeType t)
{
// Check to see if we already have a cached event provider for this type.
- Object EvProvider = GetData(t);
+ object EvProvider = GetData(t);
// If we don't then we need to create one.
if (EvProvider == null)
Marshal.InternalFinalReleaseComObject(this);
}
- private Object CreateEventProvider(RuntimeType t)
+ private object CreateEventProvider(RuntimeType t)
{
// Create the event provider for the specified type.
- Object EvProvider = Activator.CreateInstance(t, Activator.ConstructorDefault | BindingFlags.NonPublic, null, new Object[] { this }, null);
+ object EvProvider = Activator.CreateInstance(t, Activator.ConstructorDefault | BindingFlags.NonPublic, null, new object[] { this }, null);
// Attempt to cache the wrapper on the object.
if (!SetData(t, EvProvider))
internal const uint MUI_PREFERRED_UI_LANGUAGES = 0x10;
[DllImport(Libraries.Kernel32, CharSet = CharSet.Unicode, SetLastError = true, ExactSpelling = true)]
- internal static extern bool GetFileMUIPath(uint flags, String filePath, [Out] StringBuilder language, ref int languageLength, [Out] StringBuilder fileMuiPath, ref int fileMuiPathLength, ref Int64 enumerator);
+ internal static extern bool GetFileMUIPath(uint flags, string filePath, [Out] StringBuilder language, ref int languageLength, [Out] StringBuilder fileMuiPath, ref int fileMuiPathLength, ref long enumerator);
}
}
internal static extern SafeBSTRHandle SysAllocStringLen(IntPtr src, uint len);
[DllImport(Libraries.OleAut32, CharSet = CharSet.Unicode)]
- internal static extern IntPtr SysAllocStringLen(String src, int len);
+ internal static extern IntPtr SysAllocStringLen(string src, int len);
}
}
HResult = HResults.E_POINTER;
}
- public AccessViolationException(String message)
+ public AccessViolationException(string message)
: base(message)
{
HResult = HResults.E_POINTER;
}
- public AccessViolationException(String message, Exception innerException)
+ public AccessViolationException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.E_POINTER;
// message, its HRESULT set to COR_E_APPLICATION,
// and its ExceptionInfo reference set to null.
//
- public ApplicationException(String message)
+ public ApplicationException(string message)
: base(message)
{
HResult = HResults.COR_E_APPLICATION;
}
- public ApplicationException(String message, Exception innerException)
+ public ApplicationException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_APPLICATION;
HResult = HResults.E_POINTER;
}
- public ArgumentNullException(String paramName)
+ public ArgumentNullException(string paramName)
: base(SR.ArgumentNull_Generic, paramName)
{
HResult = HResults.E_POINTER;
}
- public ArgumentNullException(String message, Exception innerException)
+ public ArgumentNullException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.E_POINTER;
}
- public ArgumentNullException(String paramName, String message)
+ public ArgumentNullException(string paramName, string message)
: base(message, paramName)
{
HResult = HResults.E_POINTER;
[System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
public class ArgumentOutOfRangeException : ArgumentException
{
- private Object _actualValue;
+ private object _actualValue;
// Creates a new ArgumentOutOfRangeException with its message
// string set to a default message explaining an argument was out of range.
HResult = HResults.COR_E_ARGUMENTOUTOFRANGE;
}
- public ArgumentOutOfRangeException(String paramName)
+ public ArgumentOutOfRangeException(string paramName)
: base(SR.Arg_ArgumentOutOfRangeException, paramName)
{
HResult = HResults.COR_E_ARGUMENTOUTOFRANGE;
}
- public ArgumentOutOfRangeException(String paramName, String message)
+ public ArgumentOutOfRangeException(string paramName, string message)
: base(message, paramName)
{
HResult = HResults.COR_E_ARGUMENTOUTOFRANGE;
}
- public ArgumentOutOfRangeException(String message, Exception innerException)
+ public ArgumentOutOfRangeException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_ARGUMENTOUTOFRANGE;
// We will not use this in the classlibs, but we'll provide it for
// anyone that's really interested so they don't have to stick a bunch
// of printf's in their code.
- public ArgumentOutOfRangeException(String paramName, Object actualValue, String message)
+ public ArgumentOutOfRangeException(string paramName, object actualValue, string message)
: base(message, paramName)
{
_actualValue = actualValue;
info.AddValue("ActualValue", _actualValue, typeof(object));
}
- public override String Message
+ public override string Message
{
get
{
- String s = base.Message;
+ string s = base.Message;
if (_actualValue != null)
{
- String valueMessage = SR.Format(SR.ArgumentOutOfRange_ActualValue, _actualValue.ToString());
+ string valueMessage = SR.Format(SR.ArgumentOutOfRange_ActualValue, _actualValue.ToString());
if (s == null)
return valueMessage;
return s + Environment.NewLine + valueMessage;
// Note - we don't set this anywhere in the class libraries in
// version 1, but it might come in handy for other developers who
// want to avoid sticking printf's in their code.
- public virtual Object ActualValue
+ public virtual object ActualValue
{
get { return _actualValue; }
}
// message, its HRESULT set to COR_E_ARITHMETIC,
// and its ExceptionInfo reference set to null.
//
- public ArithmeticException(String message)
+ public ArithmeticException(string message)
: base(message)
{
HResult = HResults.COR_E_ARITHMETIC;
}
- public ArithmeticException(String message, Exception innerException)
+ public ArithmeticException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_ARITHMETIC;
System.Array.Copy(_array, _offset, destination._array, destination._offset, _count);
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj is ArraySegment<T>)
return Equals((ArraySegment<T>)obj);
// message, its HRESULT set to COR_E_ARRAYTYPEMISMATCH,
// and its ExceptionInfo reference set to null.
//
- public ArrayTypeMismatchException(String message)
+ public ArrayTypeMismatchException(string message)
: base(message)
{
HResult = HResults.COR_E_ARRAYTYPEMISMATCH;
}
- public ArrayTypeMismatchException(String message, Exception innerException)
+ public ArrayTypeMismatchException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_ARRAYTYPEMISMATCH;
[System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
public partial class BadImageFormatException : SystemException
{
- private String _fileName; // The name of the corrupt PE file.
- private String _fusionLog = null; // fusion log (when applicable)
+ private string _fileName; // The name of the corrupt PE file.
+ private string _fusionLog = null; // fusion log (when applicable)
public BadImageFormatException()
: base(SR.Arg_BadImageFormatException)
HResult = HResults.COR_E_BADIMAGEFORMAT;
}
- public BadImageFormatException(String message)
+ public BadImageFormatException(string message)
: base(message)
{
HResult = HResults.COR_E_BADIMAGEFORMAT;
}
- public BadImageFormatException(String message, Exception inner)
+ public BadImageFormatException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_BADIMAGEFORMAT;
}
- public BadImageFormatException(String message, String fileName) : base(message)
+ public BadImageFormatException(string message, string fileName) : base(message)
{
HResult = HResults.COR_E_BADIMAGEFORMAT;
_fileName = fileName;
}
- public BadImageFormatException(String message, String fileName, Exception inner)
+ public BadImageFormatException(string message, string fileName, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_BADIMAGEFORMAT;
info.AddValue("BadImageFormat_FusionLog", _fusionLog, typeof(string));
}
- public override String Message
+ public override string Message
{
get
{
}
}
- public String FileName
+ public string FileName
{
get { return _fileName; }
}
- public override String ToString()
+ public override string ToString()
{
- String s = GetType().ToString() + ": " + Message;
+ string s = GetType().ToString() + ": " + Message;
if (_fileName != null && _fileName.Length != 0)
s += Environment.NewLine + SR.Format(SR.IO_FileName_Name, _fileName);
return s;
}
- public String FusionLog
+ public string FusionLog
{
get { return _fusionLog; }
}
if (length > (int.MaxValue / 3))
{
- // (Int32.MaxValue / 3) == 715,827,882 Bytes == 699 MB
+ // (int.MaxValue / 3) == 715,827,882 Bytes == 699 MB
throw new ArgumentOutOfRangeException(nameof(length), SR.Format(SR.ArgumentOutOfRange_LengthTooLarge, (int.MaxValue / 3)));
}
{
[Serializable]
[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public struct Boolean : IComparable, IConvertible, IComparable<Boolean>, IEquatable<Boolean>
+ public struct Boolean : IComparable, IConvertible, IComparable<bool>, IEquatable<bool>
{
//
// Member Variables
// The internal string representation of true.
//
- internal const String TrueLiteral = "True";
+ internal const string TrueLiteral = "True";
// The internal string representation of false.
//
- internal const String FalseLiteral = "False";
+ internal const string FalseLiteral = "False";
//
// The public string representation of true.
//
- public static readonly String TrueString = TrueLiteral;
+ public static readonly string TrueString = TrueLiteral;
// The public string representation of false.
//
- public static readonly String FalseString = FalseLiteral;
+ public static readonly string FalseString = FalseLiteral;
//
// Overriden Instance Methods
**Exceptions: None.
==============================================================================*/
// Converts the boolean value of this instance to a String.
- public override String ToString()
+ public override string ToString()
{
if (false == m_value)
{
return TrueLiteral;
}
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
return ToString();
}
}
// Determines whether two Boolean objects are equal.
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
//If it's not a boolean, we're definitely not equal
- if (!(obj is Boolean))
+ if (!(obj is bool))
{
return false;
}
- return (m_value == ((Boolean)obj).m_value);
+ return (m_value == ((bool)obj).m_value);
}
[NonVersionable]
- public bool Equals(Boolean obj)
+ public bool Equals(bool obj)
{
return m_value == obj;
}
//
// Returns a value less than zero if this object
//
- public int CompareTo(Object obj)
+ public int CompareTo(object obj)
{
if (obj == null)
{
return 1;
}
- if (!(obj is Boolean))
+ if (!(obj is bool))
{
throw new ArgumentException(SR.Arg_MustBeBoolean);
}
- if (m_value == ((Boolean)obj).m_value)
+ if (m_value == ((bool)obj).m_value)
{
return 0;
}
return 1;
}
- public int CompareTo(Boolean value)
+ public int CompareTo(bool value)
{
if (m_value == value)
{
// Determines whether a String represents true or false.
//
- public static Boolean Parse(String value)
+ public static bool Parse(string value)
{
if (value == null) throw new ArgumentNullException(nameof(value));
return Parse(value.AsSpan());
// Determines whether a String represents true or false.
//
- public static Boolean TryParse(String value, out Boolean result)
+ public static bool TryParse(string value, out bool result)
{
if (value == null)
{
int start = 0;
while (start < value.Length)
{
- if (!Char.IsWhiteSpace(value[start]) && value[start] != nullChar)
+ if (!char.IsWhiteSpace(value[start]) && value[start] != nullChar)
{
break;
}
int end = value.Length - 1;
while (end >= start)
{
- if (!Char.IsWhiteSpace(value[end]) && value[end] != nullChar)
+ if (!char.IsWhiteSpace(value[end]) && value[end] != nullChar)
{
break;
}
return Convert.ToDouble(m_value);
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
return Convert.ToDecimal(m_value);
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Boolean", "DateTime"));
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
[Serializable]
[StructLayout(LayoutKind.Sequential)]
[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public struct Byte : IComparable, IConvertible, IFormattable, IComparable<Byte>, IEquatable<Byte>, ISpanFormattable
+ public struct Byte : IComparable, IConvertible, IFormattable, IComparable<byte>, IEquatable<byte>, ISpanFormattable
{
private byte m_value; // Do not rename (binary serialization)
// null is considered to be less than any instance.
// If object is not of type byte, this method throws an ArgumentException.
//
- public int CompareTo(Object value)
+ public int CompareTo(object value)
{
if (value == null)
{
return 1;
}
- if (!(value is Byte))
+ if (!(value is byte))
{
throw new ArgumentException(SR.Arg_MustBeByte);
}
- return m_value - (((Byte)value).m_value);
+ return m_value - (((byte)value).m_value);
}
- public int CompareTo(Byte value)
+ public int CompareTo(byte value)
{
return m_value - value;
}
// Determines whether two Byte objects are equal.
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
- if (!(obj is Byte))
+ if (!(obj is byte))
{
return false;
}
- return m_value == ((Byte)obj).m_value;
+ return m_value == ((byte)obj).m_value;
}
[NonVersionable]
- public bool Equals(Byte obj)
+ public bool Equals(byte obj)
{
return m_value == obj;
}
return m_value;
}
- public static byte Parse(String s)
+ public static byte Parse(string s)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
}
- public static byte Parse(String s, NumberStyles style)
+ public static byte Parse(string s, NumberStyles style)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Parse((ReadOnlySpan<char>)s, style, NumberFormatInfo.CurrentInfo);
}
- public static byte Parse(String s, IFormatProvider provider)
+ public static byte Parse(string s, IFormatProvider provider)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
// Parses an unsigned byte from a String in the given style. If
// a NumberFormatInfo isn't specified, the current culture's
// NumberFormatInfo is assumed.
- public static byte Parse(String s, NumberStyles style, IFormatProvider provider)
+ public static byte Parse(string s, NumberStyles style, IFormatProvider provider)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return (byte)i;
}
- public static bool TryParse(String s, out Byte result)
+ public static bool TryParse(string s, out byte result)
{
if (s == null)
{
return TryParse(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
}
- public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out Byte result)
+ public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out byte result)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
}
- private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out Byte result)
+ private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out byte result)
{
result = 0;
int i;
return true;
}
- public override String ToString()
+ public override string ToString()
{
return Number.FormatInt32(m_value, null, null);
}
- public String ToString(String format)
+ public string ToString(string format)
{
return Number.FormatInt32(m_value, format, null);
}
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
return Number.FormatInt32(m_value, null, provider);
}
- public String ToString(String format, IFormatProvider provider)
+ public string ToString(string format, IFormatProvider provider)
{
return Number.FormatInt32(m_value, format, provider);
}
return Convert.ToDouble(m_value);
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
return Convert.ToDecimal(m_value);
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Byte", "DateTime"));
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
[Serializable]
[StructLayout(LayoutKind.Sequential)]
[System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public struct Char : IComparable, IComparable<Char>, IEquatable<Char>, IConvertible
+ public struct Char : IComparable, IComparable<char>, IEquatable<char>, IConvertible
{
//
// Member Variables
// Return the Unicode category for Unicode character <= 0x00ff.
private static UnicodeCategory GetLatin1UnicodeCategory(char ch)
{
- Debug.Assert(IsLatin1(ch), "Char.GetLatin1UnicodeCategory(): ch should be <= 007f");
+ Debug.Assert(IsLatin1(ch), "char.GetLatin1UnicodeCategory(): ch should be <= 007f");
return (UnicodeCategory)(s_categoryForLatin1[(int)ch]);
}
// Used for comparing two boxed Char objects.
//
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
- if (!(obj is Char))
+ if (!(obj is char))
{
return false;
}
- return (m_value == ((Char)obj).m_value);
+ return (m_value == ((char)obj).m_value);
}
[System.Runtime.Versioning.NonVersionable]
- public bool Equals(Char obj)
+ public bool Equals(char obj)
{
return m_value == obj;
}
// null is considered to be less than any instance.
// If object is not of type Char, this method throws an ArgumentException.
//
- public int CompareTo(Object value)
+ public int CompareTo(object value)
{
if (value == null)
{
return 1;
}
- if (!(value is Char))
+ if (!(value is char))
{
throw new ArgumentException(SR.Arg_MustBeChar);
}
- return (m_value - ((Char)value).m_value);
+ return (m_value - ((char)value).m_value);
}
- public int CompareTo(Char value)
+ public int CompareTo(char value)
{
return (m_value - value);
}
// Overrides System.Object.ToString.
- public override String ToString()
+ public override string ToString()
{
- return Char.ToString(m_value);
+ return char.ToString(m_value);
}
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
- return Char.ToString(m_value);
+ return char.ToString(m_value);
}
//
// Provides a string representation of a character.
public static string ToString(char c) => string.CreateFromChar(c);
- public static char Parse(String s)
+ public static char Parse(string s)
{
if (s == null)
{
return s[0];
}
- public static bool TryParse(String s, out Char result)
+ public static bool TryParse(string s, out char result)
{
result = '\0';
if (s == null)
// Static Methods
//
/*=================================ISDIGIT======================================
- **A wrapper for Char. Returns a boolean indicating whether **
+ **A wrapper for char. Returns a boolean indicating whether **
**character c is considered to be a digit. **
==============================================================================*/
// Determines whether a character is a digit.
}
/*=================================ISLETTER=====================================
- **A wrapper for Char. Returns a boolean indicating whether **
+ **A wrapper for char. Returns a boolean indicating whether **
**character c is considered to be a letter. **
==============================================================================*/
// Determines whether a character is a letter.
}
/*===============================ISWHITESPACE===================================
- **A wrapper for Char. Returns a boolean indicating whether **
+ **A wrapper for char. Returns a boolean indicating whether **
**character c is considered to be a whitespace character. **
==============================================================================*/
// Determines whether a character is whitespace.
}
/*=================================TOUPPER======================================
- **A wrapper for Char.toUpperCase. Converts character c to its **
+ **A wrapper for char.ToUpperCase. Converts character c to its **
**uppercase equivalent. If c is already an uppercase character or is not an **
**alphabetic, nothing happens. **
==============================================================================*/
}
/*=================================TOLOWER======================================
- **A wrapper for Char.toLowerCase. Converts character c to its **
+ **A wrapper for char.ToLowerCase. Converts character c to its **
**lowercase equivalent. If c is already a lowercase character or is not an **
**alphabetic, nothing happens. **
==============================================================================*/
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Char", "Double"));
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Char", "Decimal"));
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Char", "DateTime"));
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
return (CharUnicodeInfo.GetUnicodeCategory(c) == UnicodeCategory.Control);
}
- public static bool IsControl(String s, int index)
+ public static bool IsControl(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
}
- public static bool IsDigit(String s, int index)
+ public static bool IsDigit(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
return (CharUnicodeInfo.GetUnicodeCategory(s, index) == UnicodeCategory.DecimalDigitNumber);
}
- public static bool IsLetter(String s, int index)
+ public static bool IsLetter(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
return (CheckLetter(CharUnicodeInfo.GetUnicodeCategory(s, index)));
}
- public static bool IsLetterOrDigit(String s, int index)
+ public static bool IsLetterOrDigit(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
return CheckLetterOrDigit(CharUnicodeInfo.GetUnicodeCategory(s, index));
}
- public static bool IsLower(String s, int index)
+ public static bool IsLower(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
return (CheckNumber(CharUnicodeInfo.GetUnicodeCategory(c)));
}
- public static bool IsNumber(String s, int index)
+ public static bool IsNumber(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
//
////////////////////////////////////////////////////////////////////////
- public static bool IsPunctuation(String s, int index)
+ public static bool IsPunctuation(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
return (CheckSeparator(CharUnicodeInfo.GetUnicodeCategory(c)));
}
- public static bool IsSeparator(String s, int index)
+ public static bool IsSeparator(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
return (c >= HIGH_SURROGATE_START && c <= LOW_SURROGATE_END);
}
- public static bool IsSurrogate(String s, int index)
+ public static bool IsSurrogate(string s, int index)
{
if (s == null)
{
return (CheckSymbol(CharUnicodeInfo.GetUnicodeCategory(c)));
}
- public static bool IsSymbol(String s, int index)
+ public static bool IsSymbol(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
}
- public static bool IsUpper(String s, int index)
+ public static bool IsUpper(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
return (CharUnicodeInfo.GetUnicodeCategory(s, index) == UnicodeCategory.UppercaseLetter);
}
- public static bool IsWhiteSpace(String s, int index)
+ public static bool IsWhiteSpace(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
return CharUnicodeInfo.GetUnicodeCategory((int)c);
}
- public static UnicodeCategory GetUnicodeCategory(String s, int index)
+ public static UnicodeCategory GetUnicodeCategory(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
return CharUnicodeInfo.GetNumericValue(c);
}
- public static double GetNumericValue(String s, int index)
+ public static double GetNumericValue(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
return ((c >= CharUnicodeInfo.HIGH_SURROGATE_START) && (c <= CharUnicodeInfo.HIGH_SURROGATE_END));
}
- public static bool IsHighSurrogate(String s, int index)
+ public static bool IsHighSurrogate(string s, int index)
{
if (s == null)
{
return ((c >= CharUnicodeInfo.LOW_SURROGATE_START) && (c <= CharUnicodeInfo.LOW_SURROGATE_END));
}
- public static bool IsLowSurrogate(String s, int index)
+ public static bool IsLowSurrogate(string s, int index)
{
if (s == null)
{
/*================================= IsSurrogatePair ============================
** Check if the string specified by the index starts with a surrogate pair.
==============================================================================*/
- public static bool IsSurrogatePair(String s, int index)
+ public static bool IsSurrogatePair(string s, int index)
{
if (s == null)
{
** Convert an UTF32 value into a surrogate pair.
==============================================================================*/
- public static String ConvertFromUtf32(int utf32)
+ public static string ConvertFromUtf32(int utf32)
{
// For UTF32 values from U+00D800 ~ U+00DFFF, we should throw. They
// are considered as irregular code unit sequence, but they are not illegal.
if (utf32 < UNICODE_PLANE01_START)
{
// This is a BMP character.
- return (Char.ToString((char)utf32));
+ return (char.ToString((char)utf32));
}
unsafe
** This method throws if a low surrogate is seen without preceding a high-surrogate.
==============================================================================*/
- public static int ConvertToUtf32(String s, int index)
+ public static int ConvertToUtf32(string s, int index)
{
if (s == null)
{
{
public sealed class CharEnumerator : IEnumerator, IEnumerator<char>, IDisposable, ICloneable
{
- private String _str;
+ private string _str;
private int _index;
private char _currentElement;
- internal CharEnumerator(String str)
+ internal CharEnumerator(string str)
{
_str = str;
_index = -1;
_str = null;
}
- Object IEnumerator.Current
+ object IEnumerator.Current
{
get { return Current; }
}
// If a doesn't implement IComparable and b does, -(b.CompareTo(a)) is returned.
// Otherwise an exception is thrown.
//
- public int Compare(Object a, Object b)
+ public int Compare(object a, object b)
{
if (a == b) return 0;
if (a == null) return -1;
[System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
public struct DictionaryEntry
{
- private Object _key; // Do not rename (binary serialization)
- private Object _value; // Do not rename (binary serialization)
+ private object _key; // Do not rename (binary serialization)
+ private object _value; // Do not rename (binary serialization)
// Constructs a new DictionaryEnumerator by setting the Key
// and Value fields appropriately.
- public DictionaryEntry(Object key, Object value)
+ public DictionaryEntry(object key, object value)
{
_key = key;
_value = value;
}
- public Object Key
+ public object Key
{
get
{
}
}
- public Object Value
+ public object Value
{
get
{
return result;
}
- internal static void ThrowOrIgnoreBadComparer(Object comparer)
+ internal static void ThrowOrIgnoreBadComparer(object comparer)
{
throw new ArgumentException(SR.Format(SR.Arg_BogusIComparer, comparer));
}
}
// Use unsigned comparison since we set index to dictionary.count+1 when the enumeration ends.
- // dictionary.count+1 could be negative if dictionary.count is Int32.MaxValue
+ // dictionary.count+1 could be negative if dictionary.count is int.MaxValue
while ((uint)_index < (uint)_dictionary._count)
{
ref Entry entry = ref _dictionary._entries[_index++];
HResult = HResults.COR_E_KEYNOTFOUND;
}
- public KeyNotFoundException(String message)
+ public KeyNotFoundException(string message)
: base(message)
{
HResult = HResults.COR_E_KEYNOTFOUND;
}
- public KeyNotFoundException(String message, Exception innerException)
+ public KeyNotFoundException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_KEYNOTFOUND;
--
*/
- private const Int32 InitialSize = 3;
+ private const int InitialSize = 3;
- private const String LoadFactorName = "LoadFactor"; // Do not rename (binary serialization)
- private const String VersionName = "Version"; // Do not rename (binary serialization)
- private const String ComparerName = "Comparer"; // Do not rename (binary serialization)
- private const String HashCodeProviderName = "HashCodeProvider"; // Do not rename (binary serialization)
- private const String HashSizeName = "HashSize"; // Must save buckets.Length. Do not rename (binary serialization)
- private const String KeysName = "Keys"; // Do not rename (binary serialization)
- private const String ValuesName = "Values"; // Do not rename (binary serialization)
- private const String KeyComparerName = "KeyComparer"; // Do not rename (binary serialization)
+ private const string LoadFactorName = "LoadFactor"; // Do not rename (binary serialization)
+ private const string VersionName = "Version"; // Do not rename (binary serialization)
+ private const string ComparerName = "Comparer"; // Do not rename (binary serialization)
+ private const string HashCodeProviderName = "HashCodeProvider"; // Do not rename (binary serialization)
+ private const string HashSizeName = "HashSize"; // Must save buckets.Length. Do not rename (binary serialization)
+ private const string KeysName = "Keys"; // Do not rename (binary serialization)
+ private const string ValuesName = "Values"; // Do not rename (binary serialization)
+ private const string KeyComparerName = "KeyComparer"; // Do not rename (binary serialization)
// Deleted entries have their key set to buckets
// This cannot be serialized
private struct bucket
{
- public Object key;
- public Object val;
+ public object key;
+ public object val;
public int hash_coll; // Store hash code; sign bit means there was a collision.
}
private ICollection _values;
private IEqualityComparer _keycomparer;
- private Object _syncRoot;
+ private object _syncRoot;
[Obsolete("Please use EqualityComparer property.")]
protected IHashCodeProvider hcp
_loadFactor = 0.72f * loadFactor;
double rawsize = capacity / _loadFactor;
- if (rawsize > Int32.MaxValue)
+ if (rawsize > int.MaxValue)
throw new ArgumentException(SR.Arg_HTCapacityOverflow, nameof(capacity));
// Avoid awfully small sizes
// The out parameter seed is h1(key), while the out parameter
// incr is h2(key, hashSize). Callers of this function should
// add incr each time through a loop.
- private uint InitHash(Object key, int hashsize, out uint seed, out uint incr)
+ private uint InitHash(object key, int hashsize, out uint seed, out uint incr)
{
// Hashcode must be positive. Also, we must not use the sign bit, since
// that is used for the collision bit.
// ArgumentException is thrown if the key is null or if the key is already
// present in the hashtable.
//
- public virtual void Add(Object key, Object value)
+ public virtual void Add(object key, object value)
{
Insert(key, value, true);
}
// Clone returns a virtually identical copy of this hash table. This does
// a shallow copy - the Objects in the table aren't cloned, only the references
// to those Objects.
- public virtual Object Clone()
+ public virtual object Clone()
{
bucket[] lbuckets = _buckets;
Hashtable ht = new Hashtable(_count, _keycomparer);
while (bucket > 0)
{
bucket--;
- Object keyv = lbuckets[bucket].key;
+ object keyv = lbuckets[bucket].key;
if ((keyv != null) && (keyv != lbuckets))
{
ht[keyv] = lbuckets[bucket].val;
}
// Checks if this hashtable contains the given key.
- public virtual bool Contains(Object key)
+ public virtual bool Contains(object key)
{
return ContainsKey(key);
}
// Checks if this hashtable contains an entry with the given key. This is
// an O(1) operation.
//
- public virtual bool ContainsKey(Object key)
+ public virtual bool ContainsKey(object key)
{
if (key == null)
{
// search and is thus be substantially slower than the ContainsKey
// method.
//
- public virtual bool ContainsValue(Object value)
+ public virtual bool ContainsValue(object value)
{
if (value == null)
{
{
for (int i = _buckets.Length; --i >= 0;)
{
- Object val = _buckets[i].val;
+ object val = _buckets[i].val;
if (val != null && val.Equals(value))
return true;
}
bucket[] lbuckets = _buckets;
for (int i = lbuckets.Length; --i >= 0;)
{
- Object keyv = lbuckets[i].key;
+ object keyv = lbuckets[i].key;
if ((keyv != null) && (keyv != _buckets))
{
array.SetValue(keyv, arrayIndex++);
bucket[] lbuckets = _buckets;
for (int i = lbuckets.Length; --i >= 0;)
{
- Object keyv = lbuckets[i].key;
+ object keyv = lbuckets[i].key;
if ((keyv != null) && (keyv != _buckets))
{
DictionaryEntry entry = new DictionaryEntry(keyv, lbuckets[i].val);
bucket[] lbuckets = _buckets;
for (int i = lbuckets.Length; --i >= 0;)
{
- Object keyv = lbuckets[i].key;
+ object keyv = lbuckets[i].key;
if ((keyv != null) && (keyv != _buckets))
{
array[index++] = new KeyValuePairs(keyv, lbuckets[i].val);
bucket[] lbuckets = _buckets;
for (int i = lbuckets.Length; --i >= 0;)
{
- Object keyv = lbuckets[i].key;
+ object keyv = lbuckets[i].key;
if ((keyv != null) && (keyv != _buckets))
{
array.SetValue(lbuckets[i].val, arrayIndex++);
// Returns the value associated with the given key. If an entry with the
// given key is not found, the returned value is null.
//
- public virtual Object this[Object key]
+ public virtual object this[object key]
{
get
{
private void UpdateVersion()
{
- // Version might become negative when version is Int32.MaxValue, but the oddity will be still be correct.
+ // Version might become negative when version is int.MaxValue, but the oddity will be still be correct.
// So we don't need to special case this.
_version++;
}
// Internal method to get the hash code for an Object. This will call
// GetHashCode() on each object if you haven't provided an IHashCodeProvider
// instance. Otherwise, it calls hcp.GetHashCode(obj).
- protected virtual int GetHash(Object key)
+ protected virtual int GetHash(object key)
{
if (_keycomparer != null)
return _keycomparer.GetHashCode(key);
// instance in the constructor, this method will call comparer.Compare(item, key).
// Otherwise, it will call item.Equals(key).
//
- protected virtual bool KeyEquals(Object item, Object key)
+ protected virtual bool KeyEquals(object item, object key)
{
Debug.Assert(key != null, "key can't be null here!");
- if (Object.ReferenceEquals(_buckets, item))
+ if (object.ReferenceEquals(_buckets, item))
{
return false;
}
- if (Object.ReferenceEquals(item, key))
+ if (object.ReferenceEquals(item, key))
return true;
if (_keycomparer != null)
// Inserts an entry into this hashtable. This method is called from the Set
// and Add methods. If the add parameter is true and the given key already
// exists in the hashtable, an exception is thrown.
- private void Insert(Object key, Object nvalue, bool add)
+ private void Insert(object key, object nvalue, bool add)
{
if (key == null)
{
throw new InvalidOperationException(SR.InvalidOperation_HashInsertFailed);
}
- private void putEntry(bucket[] newBuckets, Object key, Object nvalue, int hashcode)
+ private void putEntry(bucket[] newBuckets, object key, object nvalue, int hashcode)
{
Debug.Assert(hashcode >= 0, "hashcode >= 0"); // make sure collision bit (sign bit) wasn't set.
// key exists in the hashtable, it is removed. An ArgumentException is
// thrown if the key is null.
//
- public virtual void Remove(Object key)
+ public virtual void Remove(object key)
{
if (key == null)
{
}
// Returns the object to synchronize on for this hash table.
- public virtual Object SyncRoot
+ public virtual object SyncRoot
{
get
{
if (_syncRoot == null)
{
- System.Threading.Interlocked.CompareExchange<Object>(ref _syncRoot, new Object(), null);
+ System.Threading.Interlocked.CompareExchange<object>(ref _syncRoot, new object(), null);
}
return _syncRoot;
}
#pragma warning restore 618
info.AddValue(HashSizeName, _buckets.Length); //This is the length of the bucket array.
- Object[] serKeys = new Object[_count];
- Object[] serValues = new Object[_count];
+ object[] serKeys = new object[_count];
+ object[] serValues = new object[_count];
CopyKeys(serKeys, 0);
CopyValues(serValues, 0);
- info.AddValue(KeysName, serKeys, typeof(Object[]));
- info.AddValue(ValuesName, serValues, typeof(Object[]));
+ info.AddValue(KeysName, serKeys, typeof(object[]));
+ info.AddValue(ValuesName, serValues, typeof(object[]));
// Explicitly check to see if anyone changed the Hashtable while we
// were serializing it. That's a race in their code.
//
// DeserializationEvent Listener
//
- public virtual void OnDeserialization(Object sender)
+ public virtual void OnDeserialization(object sender)
{
if (_buckets != null)
{
IHashCodeProvider hcp = null;
#pragma warning restore 618
- Object[] serKeys = null;
- Object[] serValues = null;
+ object[] serKeys = null;
+ object[] serValues = null;
SerializationInfoEnumerator enumerator = siInfo.GetEnumerator();
#pragma warning restore 618
break;
case KeysName:
- serKeys = (Object[])siInfo.GetValue(KeysName, typeof(Object[]));
+ serKeys = (object[])siInfo.GetValue(KeysName, typeof(object[]));
break;
case ValuesName:
- serValues = (Object[])siInfo.GetValue(ValuesName, typeof(Object[]));
+ serValues = (object[])siInfo.GetValue(ValuesName, typeof(object[]));
break;
}
}
get { return _hashtable.IsSynchronized; }
}
- public virtual Object SyncRoot
+ public virtual object SyncRoot
{
get { return _hashtable.SyncRoot; }
}
get { return _hashtable.IsSynchronized; }
}
- public virtual Object SyncRoot
+ public virtual object SyncRoot
{
get { return _hashtable.SyncRoot; }
}
get { return true; }
}
- public override Object this[Object key]
+ public override object this[object key]
{
get
{
}
}
- public override Object SyncRoot
+ public override object SyncRoot
{
get { return _table.SyncRoot; }
}
- public override void Add(Object key, Object value)
+ public override void Add(object key, object value)
{
lock (_table.SyncRoot)
{
}
}
- public override bool Contains(Object key)
+ public override bool Contains(object key)
{
return _table.Contains(key);
}
- public override bool ContainsKey(Object key)
+ public override bool ContainsKey(object key)
{
if (key == null)
{
return _table.ContainsKey(key);
}
- public override bool ContainsValue(Object key)
+ public override bool ContainsValue(object key)
{
lock (_table.SyncRoot)
{
}
}
- public override Object Clone()
+ public override object Clone()
{
lock (_table.SyncRoot)
{
}
}
- public override void Remove(Object key)
+ public override void Remove(object key)
{
lock (_table.SyncRoot)
{
}
}
- public override void OnDeserialization(Object sender)
+ public override void OnDeserialization(object sender)
{
// Does nothing. We have to implement this because our parent HT implements it,
// but it doesn't do anything meaningful. The real work will be done when we
private int _version;
private bool _current;
private int _getObjectRetType; // What should GetObject return?
- private Object _currentKey;
- private Object _currentValue;
+ private object _currentKey;
+ private object _currentValue;
internal const int Keys = 1;
internal const int Values = 2;
public object Clone() => MemberwiseClone();
- public virtual Object Key
+ public virtual object Key
{
get
{
while (_bucket > 0)
{
_bucket--;
- Object keyv = _hashtable._buckets[_bucket].key;
+ object keyv = _hashtable._buckets[_bucket].key;
if ((keyv != null) && (keyv != _hashtable._buckets))
{
_currentKey = keyv;
}
- public virtual Object Current
+ public virtual object Current
{
get
{
}
}
- public virtual Object Value
+ public virtual object Value
{
get
{
// that the this pointer may not be sufficient for collections that
// wrap other collections; those should return the underlying
// collection's SyncRoot property.
- Object SyncRoot
+ object SyncRoot
{ get; }
// Is this collection synchronized (i.e., thread-safe)? If you want a
// value less than zero if x is less than y, zero if x is equal to y, or a
// value greater than zero if x is greater than y.
//
- int Compare(Object x, Object y);
+ int Compare(object x, object y);
}
}
// Interfaces are not serializable
// The Item property provides methods to read and edit entries
// in the Dictionary.
- Object this[Object key]
+ object this[object key]
{
get;
set;
// Returns whether this dictionary contains a particular key.
//
- bool Contains(Object key);
+ bool Contains(object key);
// Adds a key-value pair to the dictionary.
//
- void Add(Object key, Object value);
+ void Add(object key, object value);
// Removes all pairs from the dictionary.
void Clear();
// Removes a particular key from the dictionary.
//
- void Remove(Object key);
+ void Remove(object key);
}
}
// GetKey with no intervening calls to GetNext will return
// the same object.
//
- Object Key
+ object Key
{
get;
}
// to GetValue with no intervening calls to GetNext will
// return the same object.
//
- Object Value
+ object Value
{
get;
}
// GetCurrent with no intervening calls to MoveNext
// will return the same object.
//
- Object Current
+ object Current
{
get;
}
// that can be consumed by some of the common collections.
public interface IEqualityComparer
{
- bool Equals(Object x, Object y);
- int GetHashCode(Object obj);
+ bool Equals(object x, object y);
+ int GetHashCode(object obj);
}
}
public interface IList : ICollection
{
// The Item property provides methods to read and edit entries in the List.
- Object this[int index]
+ object this[int index]
{
get;
set;
// implementation-dependent, so while ArrayList may always insert
// in the last available location, a SortedList most likely would not.
// The return value is the position the new element was inserted in.
- int Add(Object value);
+ int Add(object value);
// Returns whether the list contains a particular item.
- bool Contains(Object value);
+ bool Contains(object value);
// Removes all items from the list.
void Clear();
// Returns the index of a particular item, if it is in the list.
// Returns -1 if the item isn't in the list.
- int IndexOf(Object value);
+ int IndexOf(object value);
// Inserts value into the list at position index.
// index must be non-negative and less than or equal to the
// number of elements in the list. If index equals the number
// of items in the list, then value is appended to the end.
- void Insert(int index, Object value);
+ void Insert(int index, object value);
// Removes an item from the list.
- void Remove(Object value);
+ void Remove(object value);
// Removes the item at position index.
void RemoveAt(int index);
{
public interface IStructuralComparable
{
- Int32 CompareTo(Object other, IComparer comparer);
+ int CompareTo(object other, IComparer comparer);
}
}
{
public interface IStructuralEquatable
{
- Boolean Equals(Object other, IEqualityComparer comparer);
+ bool Equals(object other, IEqualityComparer comparer);
int GetHashCode(IEqualityComparer comparer);
}
}
private int version; // Do not rename (binary serialization)
private int count; // Do not rename (binary serialization)
[NonSerialized]
- private Object _syncRoot;
+ private object _syncRoot;
public ListDictionaryInternal()
{
}
- public Object this[Object key]
+ public object this[object key]
{
get
{
}
}
- public Object SyncRoot
+ public object SyncRoot
{
get
{
if (_syncRoot == null)
{
- System.Threading.Interlocked.CompareExchange<Object>(ref _syncRoot, new Object(), null);
+ System.Threading.Interlocked.CompareExchange<object>(ref _syncRoot, new object(), null);
}
return _syncRoot;
}
}
}
- public void Add(Object key, Object value)
+ public void Add(object key, object value)
{
if (key == null)
{
version++;
}
- public bool Contains(Object key)
+ public bool Contains(object key)
{
if (key == null)
{
return new NodeEnumerator(this);
}
- public void Remove(Object key)
+ public void Remove(object key)
{
if (key == null)
{
current = null;
}
- public Object Current
+ public object Current
{
get
{
}
}
- public Object Key
+ public object Key
{
get
{
}
}
- public Object Value
+ public object Value
{
get
{
}
}
- Object ICollection.SyncRoot
+ object ICollection.SyncRoot
{
get
{
current = null;
}
- public Object Current
+ public object Current
{
get
{
[Serializable]
private class DictionaryNode
{
- public Object key;
- public Object value;
+ public object key;
+ public object value;
public DictionaryNode next;
}
}
{
private IList<T> items; // Do not rename (binary serialization)
[NonSerialized]
- private Object _syncRoot;
+ private object _syncRoot;
public Collection()
{
}
else
{
- System.Threading.Interlocked.CompareExchange<Object>(ref _syncRoot, new Object(), null);
+ System.Threading.Interlocked.CompareExchange<object>(ref _syncRoot, new object(), null);
}
}
return _syncRoot;
{
private IList<T> list; // Do not rename (binary serialization)
[NonSerialized]
- private Object _syncRoot;
+ private object _syncRoot;
public ReadOnlyCollection(IList<T> list)
{
}
else
{
- System.Threading.Interlocked.CompareExchange<Object>(ref _syncRoot, new Object(), null);
+ System.Threading.Interlocked.CompareExchange<object>(ref _syncRoot, new object(), null);
}
}
return _syncRoot;
{
//A typeof operation is fairly expensive (does a system call), so we'll cache these here
//statically. These are exactly lined up with the TypeCode, eg. ConvertType[TypeCode.Int16]
- //will give you the type of an Int16.
+ //will give you the type of an short.
internal static readonly Type[] ConvertTypes = {
typeof(System.Empty),
- typeof(Object),
+ typeof(object),
typeof(System.DBNull),
- typeof(Boolean),
- typeof(Char),
- typeof(SByte),
- typeof(Byte),
- typeof(Int16),
- typeof(UInt16),
- typeof(Int32),
- typeof(UInt32),
- typeof(Int64),
- typeof(UInt64),
- typeof(Single),
- typeof(Double),
- typeof(Decimal),
+ typeof(bool),
+ typeof(char),
+ typeof(sbyte),
+ typeof(byte),
+ typeof(short),
+ typeof(ushort),
+ typeof(int),
+ typeof(uint),
+ typeof(long),
+ typeof(ulong),
+ typeof(float),
+ typeof(double),
+ typeof(decimal),
typeof(DateTime),
- typeof(Object), //TypeCode is discontinuous so we need a placeholder.
- typeof(String)
+ typeof(object), //TypeCode is discontinuous so we need a placeholder.
+ typeof(string)
};
// Need to special case Enum because typecode will be underlying type, e.g. Int32
't','u','v','w','x','y','z','0','1','2','3','4','5','6','7',
'8','9','+','/','=' };
- private const Int32 base64LineBreakPosition = 76;
+ private const int base64LineBreakPosition = 76;
#if DEBUG
private static bool TriggerAsserts = DoAsserts();
Debug.Assert(ConvertTypes.Length == ((int)TypeCode.String + 1), "[Convert.cctor]ConvertTypes.Length == ((int)TypeCode.String + 1)");
Debug.Assert(ConvertTypes[(int)TypeCode.Empty] == typeof(System.Empty),
"[Convert.cctor]ConvertTypes[(int)TypeCode.Empty]==typeof(System.Empty)");
- Debug.Assert(ConvertTypes[(int)TypeCode.String] == typeof(String),
+ Debug.Assert(ConvertTypes[(int)TypeCode.String] == typeof(string),
"[Convert.cctor]ConvertTypes[(int)TypeCode.String]==typeof(System.String)");
Debug.Assert(ConvertTypes[(int)TypeCode.Int32] == typeof(int),
"[Convert.cctor]ConvertTypes[(int)TypeCode.Int32]==typeof(int)");
}
#endif
- public static readonly Object DBNull = System.DBNull.Value;
+ public static readonly object DBNull = System.DBNull.Value;
// Returns the type code for the given object. If the argument is null,
// the result is TypeCode.Empty. If the argument is not a value (i.e. if
// object already has the given type code, in which case the object is
// simply returned. Otherwise, the appropriate ToXXX() is invoked on the
// object's implementation of IConvertible.
- public static Object ChangeType(Object value, TypeCode typeCode)
+ public static object ChangeType(object value, TypeCode typeCode)
{
return ChangeType(value, typeCode, CultureInfo.CurrentCulture);
}
- public static Object ChangeType(Object value, TypeCode typeCode, IFormatProvider provider)
+ public static object ChangeType(object value, TypeCode typeCode, IFormatProvider provider)
{
if (value == null && (typeCode == TypeCode.Empty || typeCode == TypeCode.String || typeCode == TypeCode.Object))
{
}
// This line is invalid for things like Enums that return a TypeCode
- // of Int32, but the object can't actually be cast to an Int32.
+ // of int, but the object can't actually be cast to an int.
// if (v.GetTypeCode() == typeCode) return value;
switch (typeCode)
{
}
}
- internal static Object DefaultToType(IConvertible value, Type targetType, IFormatProvider provider)
+ internal static object DefaultToType(IConvertible value, Type targetType, IFormatProvider provider)
{
Debug.Assert(value != null, "[Convert.DefaultToType]value!=null");
if (targetType == null)
if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.String]))
return value.ToString(provider);
if (ReferenceEquals(targetType, ConvertTypes[(int)TypeCode.Object]))
- return (Object)value;
+ return (object)value;
// Need to special case Enum because typecode will be underlying type, e.g. Int32
if (ReferenceEquals(targetType, EnumType))
return (Enum)value;
throw new InvalidCastException(string.Format(SR.InvalidCast_FromTo, value.GetType().FullName, targetType.FullName));
}
- public static Object ChangeType(Object value, Type conversionType)
+ public static object ChangeType(object value, Type conversionType)
{
return ChangeType(value, conversionType, CultureInfo.CurrentCulture);
}
- public static Object ChangeType(Object value, Type conversionType, IFormatProvider provider)
+ public static object ChangeType(object value, Type conversionType, IFormatProvider provider)
{
if (conversionType is null)
{
if (ReferenceEquals(conversionType, ConvertTypes[(int)TypeCode.String]))
return ic.ToString(provider);
if (ReferenceEquals(conversionType, ConvertTypes[(int)TypeCode.Object]))
- return (Object)value;
+ return (object)value;
return ic.ToType(conversionType, provider);
}
private static void ThrowUInt64OverflowException() { throw new OverflowException(SR.Overflow_UInt64); }
// Conversions to Boolean
- public static bool ToBoolean(Object value)
+ public static bool ToBoolean(object value)
{
return value == null ? false : ((IConvertible)value).ToBoolean(null);
}
- public static bool ToBoolean(Object value, IFormatProvider provider)
+ public static bool ToBoolean(object value, IFormatProvider provider)
{
return value == null ? false : ((IConvertible)value).ToBoolean(provider);
}
return value != 0;
}
- public static bool ToBoolean(String value)
+ public static bool ToBoolean(string value)
{
if (value == null)
return false;
- return Boolean.Parse(value);
+ return bool.Parse(value);
}
- public static bool ToBoolean(String value, IFormatProvider provider)
+ public static bool ToBoolean(string value, IFormatProvider provider)
{
if (value == null)
return false;
- return Boolean.Parse(value);
+ return bool.Parse(value);
}
public static bool ToBoolean(float value)
public static char ToChar(int value)
{
- if (value < 0 || value > Char.MaxValue) ThrowCharOverflowException();
+ if (value < 0 || value > char.MaxValue) ThrowCharOverflowException();
return (char)value;
}
[CLSCompliant(false)]
public static char ToChar(uint value)
{
- if (value > Char.MaxValue) ThrowCharOverflowException();
+ if (value > char.MaxValue) ThrowCharOverflowException();
return (char)value;
}
public static char ToChar(long value)
{
- if (value < 0 || value > Char.MaxValue) ThrowCharOverflowException();
+ if (value < 0 || value > char.MaxValue) ThrowCharOverflowException();
return (char)value;
}
[CLSCompliant(false)]
public static char ToChar(ulong value)
{
- if (value > Char.MaxValue) ThrowCharOverflowException();
+ if (value > char.MaxValue) ThrowCharOverflowException();
return (char)value;
}
// @VariantSwitch
// Remove FormatExceptions;
//
- public static char ToChar(String value)
+ public static char ToChar(string value)
{
return ToChar(value, null);
}
- public static char ToChar(String value, IFormatProvider provider)
+ public static char ToChar(string value, IFormatProvider provider)
{
if (value == null)
throw new ArgumentNullException(nameof(value));
[CLSCompliant(false)]
public static sbyte ToSByte(bool value)
{
- return value ? (sbyte)Boolean.True : (sbyte)Boolean.False;
+ return value ? (sbyte)bool.True : (sbyte)bool.False;
}
[CLSCompliant(false)]
[CLSCompliant(false)]
public static sbyte ToSByte(char value)
{
- if (value > SByte.MaxValue) ThrowSByteOverflowException();
+ if (value > sbyte.MaxValue) ThrowSByteOverflowException();
return (sbyte)value;
}
[CLSCompliant(false)]
public static sbyte ToSByte(byte value)
{
- if (value > SByte.MaxValue) ThrowSByteOverflowException();
+ if (value > sbyte.MaxValue) ThrowSByteOverflowException();
return (sbyte)value;
}
[CLSCompliant(false)]
public static sbyte ToSByte(short value)
{
- if (value < SByte.MinValue || value > SByte.MaxValue) ThrowSByteOverflowException();
+ if (value < sbyte.MinValue || value > sbyte.MaxValue) ThrowSByteOverflowException();
return (sbyte)value;
}
[CLSCompliant(false)]
public static sbyte ToSByte(ushort value)
{
- if (value > SByte.MaxValue) ThrowSByteOverflowException();
+ if (value > sbyte.MaxValue) ThrowSByteOverflowException();
return (sbyte)value;
}
[CLSCompliant(false)]
public static sbyte ToSByte(int value)
{
- if (value < SByte.MinValue || value > SByte.MaxValue) ThrowSByteOverflowException();
+ if (value < sbyte.MinValue || value > sbyte.MaxValue) ThrowSByteOverflowException();
return (sbyte)value;
}
[CLSCompliant(false)]
public static sbyte ToSByte(uint value)
{
- if (value > SByte.MaxValue) ThrowSByteOverflowException();
+ if (value > sbyte.MaxValue) ThrowSByteOverflowException();
return (sbyte)value;
}
[CLSCompliant(false)]
public static sbyte ToSByte(long value)
{
- if (value < SByte.MinValue || value > SByte.MaxValue) ThrowSByteOverflowException();
+ if (value < sbyte.MinValue || value > sbyte.MaxValue) ThrowSByteOverflowException();
return (sbyte)value;
}
[CLSCompliant(false)]
public static sbyte ToSByte(ulong value)
{
- if (value > (ulong)SByte.MaxValue) ThrowSByteOverflowException();
+ if (value > (ulong)sbyte.MaxValue) ThrowSByteOverflowException();
return (sbyte)value;
}
[CLSCompliant(false)]
public static sbyte ToSByte(decimal value)
{
- return Decimal.ToSByte(Decimal.Round(value, 0));
+ return decimal.ToSByte(decimal.Round(value, 0));
}
[CLSCompliant(false)]
- public static sbyte ToSByte(String value)
+ public static sbyte ToSByte(string value)
{
if (value == null)
return 0;
- return SByte.Parse(value, CultureInfo.CurrentCulture);
+ return sbyte.Parse(value, CultureInfo.CurrentCulture);
}
[CLSCompliant(false)]
- public static sbyte ToSByte(String value, IFormatProvider provider)
+ public static sbyte ToSByte(string value, IFormatProvider provider)
{
- return SByte.Parse(value, NumberStyles.Integer, provider);
+ return sbyte.Parse(value, NumberStyles.Integer, provider);
}
[CLSCompliant(false)]
public static byte ToByte(bool value)
{
- return value ? (byte)Boolean.True : (byte)Boolean.False;
+ return value ? (byte)bool.True : (byte)bool.False;
}
public static byte ToByte(byte value)
public static byte ToByte(char value)
{
- if (value > Byte.MaxValue) ThrowByteOverflowException();
+ if (value > byte.MaxValue) ThrowByteOverflowException();
return (byte)value;
}
[CLSCompliant(false)]
public static byte ToByte(sbyte value)
{
- if (value < Byte.MinValue) ThrowByteOverflowException();
+ if (value < byte.MinValue) ThrowByteOverflowException();
return (byte)value;
}
public static byte ToByte(short value)
{
- if (value < Byte.MinValue || value > Byte.MaxValue) ThrowByteOverflowException();
+ if (value < byte.MinValue || value > byte.MaxValue) ThrowByteOverflowException();
return (byte)value;
}
[CLSCompliant(false)]
public static byte ToByte(ushort value)
{
- if (value > Byte.MaxValue) ThrowByteOverflowException();
+ if (value > byte.MaxValue) ThrowByteOverflowException();
return (byte)value;
}
public static byte ToByte(int value)
{
- if (value < Byte.MinValue || value > Byte.MaxValue) ThrowByteOverflowException();
+ if (value < byte.MinValue || value > byte.MaxValue) ThrowByteOverflowException();
return (byte)value;
}
[CLSCompliant(false)]
public static byte ToByte(uint value)
{
- if (value > Byte.MaxValue) ThrowByteOverflowException();
+ if (value > byte.MaxValue) ThrowByteOverflowException();
return (byte)value;
}
public static byte ToByte(long value)
{
- if (value < Byte.MinValue || value > Byte.MaxValue) ThrowByteOverflowException();
+ if (value < byte.MinValue || value > byte.MaxValue) ThrowByteOverflowException();
return (byte)value;
}
[CLSCompliant(false)]
public static byte ToByte(ulong value)
{
- if (value > Byte.MaxValue) ThrowByteOverflowException();
+ if (value > byte.MaxValue) ThrowByteOverflowException();
return (byte)value;
}
public static byte ToByte(decimal value)
{
- return Decimal.ToByte(Decimal.Round(value, 0));
+ return decimal.ToByte(decimal.Round(value, 0));
}
- public static byte ToByte(String value)
+ public static byte ToByte(string value)
{
if (value == null)
return 0;
- return Byte.Parse(value, CultureInfo.CurrentCulture);
+ return byte.Parse(value, CultureInfo.CurrentCulture);
}
- public static byte ToByte(String value, IFormatProvider provider)
+ public static byte ToByte(string value, IFormatProvider provider)
{
if (value == null)
return 0;
- return Byte.Parse(value, NumberStyles.Integer, provider);
+ return byte.Parse(value, NumberStyles.Integer, provider);
}
public static byte ToByte(DateTime value)
public static short ToInt16(bool value)
{
- return value ? (short)Boolean.True : (short)Boolean.False;
+ return value ? (short)bool.True : (short)bool.False;
}
public static short ToInt16(char value)
{
- if (value > Int16.MaxValue) ThrowInt16OverflowException();
+ if (value > short.MaxValue) ThrowInt16OverflowException();
return (short)value;
}
[CLSCompliant(false)]
public static short ToInt16(ushort value)
{
- if (value > Int16.MaxValue) ThrowInt16OverflowException();
+ if (value > short.MaxValue) ThrowInt16OverflowException();
return (short)value;
}
public static short ToInt16(int value)
{
- if (value < Int16.MinValue || value > Int16.MaxValue) ThrowInt16OverflowException();
+ if (value < short.MinValue || value > short.MaxValue) ThrowInt16OverflowException();
return (short)value;
}
[CLSCompliant(false)]
public static short ToInt16(uint value)
{
- if (value > Int16.MaxValue) ThrowInt16OverflowException();
+ if (value > short.MaxValue) ThrowInt16OverflowException();
return (short)value;
}
public static short ToInt16(long value)
{
- if (value < Int16.MinValue || value > Int16.MaxValue) ThrowInt16OverflowException();
+ if (value < short.MinValue || value > short.MaxValue) ThrowInt16OverflowException();
return (short)value;
}
[CLSCompliant(false)]
public static short ToInt16(ulong value)
{
- if (value > (ulong)Int16.MaxValue) ThrowInt16OverflowException();
+ if (value > (ulong)short.MaxValue) ThrowInt16OverflowException();
return (short)value;
}
public static short ToInt16(decimal value)
{
- return Decimal.ToInt16(Decimal.Round(value, 0));
+ return decimal.ToInt16(decimal.Round(value, 0));
}
- public static short ToInt16(String value)
+ public static short ToInt16(string value)
{
if (value == null)
return 0;
- return Int16.Parse(value, CultureInfo.CurrentCulture);
+ return short.Parse(value, CultureInfo.CurrentCulture);
}
- public static short ToInt16(String value, IFormatProvider provider)
+ public static short ToInt16(string value, IFormatProvider provider)
{
if (value == null)
return 0;
- return Int16.Parse(value, NumberStyles.Integer, provider);
+ return short.Parse(value, NumberStyles.Integer, provider);
}
public static short ToInt16(DateTime value)
[CLSCompliant(false)]
public static ushort ToUInt16(bool value)
{
- return value ? (ushort)Boolean.True : (ushort)Boolean.False;
+ return value ? (ushort)bool.True : (ushort)bool.False;
}
[CLSCompliant(false)]
[CLSCompliant(false)]
public static ushort ToUInt16(int value)
{
- if (value < 0 || value > UInt16.MaxValue) ThrowUInt16OverflowException();
+ if (value < 0 || value > ushort.MaxValue) ThrowUInt16OverflowException();
return (ushort)value;
}
[CLSCompliant(false)]
public static ushort ToUInt16(uint value)
{
- if (value > UInt16.MaxValue) ThrowUInt16OverflowException();
+ if (value > ushort.MaxValue) ThrowUInt16OverflowException();
return (ushort)value;
}
[CLSCompliant(false)]
public static ushort ToUInt16(long value)
{
- if (value < 0 || value > UInt16.MaxValue) ThrowUInt16OverflowException();
+ if (value < 0 || value > ushort.MaxValue) ThrowUInt16OverflowException();
return (ushort)value;
}
[CLSCompliant(false)]
public static ushort ToUInt16(ulong value)
{
- if (value > UInt16.MaxValue) ThrowUInt16OverflowException();
+ if (value > ushort.MaxValue) ThrowUInt16OverflowException();
return (ushort)value;
}
[CLSCompliant(false)]
public static ushort ToUInt16(decimal value)
{
- return Decimal.ToUInt16(Decimal.Round(value, 0));
+ return decimal.ToUInt16(decimal.Round(value, 0));
}
[CLSCompliant(false)]
- public static ushort ToUInt16(String value)
+ public static ushort ToUInt16(string value)
{
if (value == null)
return 0;
- return UInt16.Parse(value, CultureInfo.CurrentCulture);
+ return ushort.Parse(value, CultureInfo.CurrentCulture);
}
[CLSCompliant(false)]
- public static ushort ToUInt16(String value, IFormatProvider provider)
+ public static ushort ToUInt16(string value, IFormatProvider provider)
{
if (value == null)
return 0;
- return UInt16.Parse(value, NumberStyles.Integer, provider);
+ return ushort.Parse(value, NumberStyles.Integer, provider);
}
[CLSCompliant(false)]
public static int ToInt32(bool value)
{
- return value ? Boolean.True : Boolean.False;
+ return value ? bool.True : bool.False;
}
public static int ToInt32(char value)
[CLSCompliant(false)]
public static int ToInt32(uint value)
{
- if (value > Int32.MaxValue) ThrowInt32OverflowException();
+ if (value > int.MaxValue) ThrowInt32OverflowException();
return (int)value;
}
public static int ToInt32(long value)
{
- if (value < Int32.MinValue || value > Int32.MaxValue) ThrowInt32OverflowException();
+ if (value < int.MinValue || value > int.MaxValue) ThrowInt32OverflowException();
return (int)value;
}
[CLSCompliant(false)]
public static int ToInt32(ulong value)
{
- if (value > Int32.MaxValue) ThrowInt32OverflowException();
+ if (value > int.MaxValue) ThrowInt32OverflowException();
return (int)value;
}
public static int ToInt32(decimal value)
{
- return Decimal.ToInt32(Decimal.Round(value, 0));
+ return decimal.ToInt32(decimal.Round(value, 0));
}
- public static int ToInt32(String value)
+ public static int ToInt32(string value)
{
if (value == null)
return 0;
- return Int32.Parse(value, CultureInfo.CurrentCulture);
+ return int.Parse(value, CultureInfo.CurrentCulture);
}
- public static int ToInt32(String value, IFormatProvider provider)
+ public static int ToInt32(string value, IFormatProvider provider)
{
if (value == null)
return 0;
- return Int32.Parse(value, NumberStyles.Integer, provider);
+ return int.Parse(value, NumberStyles.Integer, provider);
}
public static int ToInt32(DateTime value)
[CLSCompliant(false)]
public static uint ToUInt32(bool value)
{
- return value ? (uint)Boolean.True : (uint)Boolean.False;
+ return value ? (uint)bool.True : (uint)bool.False;
}
[CLSCompliant(false)]
[CLSCompliant(false)]
public static uint ToUInt32(long value)
{
- if (value < 0 || value > UInt32.MaxValue) ThrowUInt32OverflowException();
+ if (value < 0 || value > uint.MaxValue) ThrowUInt32OverflowException();
return (uint)value;
}
[CLSCompliant(false)]
public static uint ToUInt32(ulong value)
{
- if (value > UInt32.MaxValue) ThrowUInt32OverflowException();
+ if (value > uint.MaxValue) ThrowUInt32OverflowException();
return (uint)value;
}
[CLSCompliant(false)]
public static uint ToUInt32(decimal value)
{
- return Decimal.ToUInt32(Decimal.Round(value, 0));
+ return decimal.ToUInt32(decimal.Round(value, 0));
}
[CLSCompliant(false)]
- public static uint ToUInt32(String value)
+ public static uint ToUInt32(string value)
{
if (value == null)
return 0;
- return UInt32.Parse(value, CultureInfo.CurrentCulture);
+ return uint.Parse(value, CultureInfo.CurrentCulture);
}
[CLSCompliant(false)]
- public static uint ToUInt32(String value, IFormatProvider provider)
+ public static uint ToUInt32(string value, IFormatProvider provider)
{
if (value == null)
return 0;
- return UInt32.Parse(value, NumberStyles.Integer, provider);
+ return uint.Parse(value, NumberStyles.Integer, provider);
}
[CLSCompliant(false)]
public static long ToInt64(bool value)
{
- return value ? Boolean.True : Boolean.False;
+ return value ? bool.True : bool.False;
}
public static long ToInt64(char value)
[CLSCompliant(false)]
public static long ToInt64(ulong value)
{
- if (value > Int64.MaxValue) ThrowInt64OverflowException();
+ if (value > long.MaxValue) ThrowInt64OverflowException();
return (long)value;
}
public static long ToInt64(decimal value)
{
- return Decimal.ToInt64(Decimal.Round(value, 0));
+ return decimal.ToInt64(decimal.Round(value, 0));
}
public static long ToInt64(string value)
{
if (value == null)
return 0;
- return Int64.Parse(value, CultureInfo.CurrentCulture);
+ return long.Parse(value, CultureInfo.CurrentCulture);
}
- public static long ToInt64(String value, IFormatProvider provider)
+ public static long ToInt64(string value, IFormatProvider provider)
{
if (value == null)
return 0;
- return Int64.Parse(value, NumberStyles.Integer, provider);
+ return long.Parse(value, NumberStyles.Integer, provider);
}
public static long ToInt64(DateTime value)
[CLSCompliant(false)]
public static ulong ToUInt64(bool value)
{
- return value ? (ulong)Boolean.True : (ulong)Boolean.False;
+ return value ? (ulong)bool.True : (ulong)bool.False;
}
[CLSCompliant(false)]
}
[CLSCompliant(false)]
- public static ulong ToUInt64(UInt64 value)
+ public static ulong ToUInt64(ulong value)
{
return value;
}
[CLSCompliant(false)]
public static ulong ToUInt64(decimal value)
{
- return Decimal.ToUInt64(Decimal.Round(value, 0));
+ return decimal.ToUInt64(decimal.Round(value, 0));
}
[CLSCompliant(false)]
- public static ulong ToUInt64(String value)
+ public static ulong ToUInt64(string value)
{
if (value == null)
return 0;
- return UInt64.Parse(value, CultureInfo.CurrentCulture);
+ return ulong.Parse(value, CultureInfo.CurrentCulture);
}
[CLSCompliant(false)]
- public static ulong ToUInt64(String value, IFormatProvider provider)
+ public static ulong ToUInt64(string value, IFormatProvider provider)
{
if (value == null)
return 0;
- return UInt64.Parse(value, NumberStyles.Integer, provider);
+ return ulong.Parse(value, NumberStyles.Integer, provider);
}
[CLSCompliant(false)]
return (float)value;
}
- public static float ToSingle(String value)
+ public static float ToSingle(string value)
{
if (value == null)
return 0;
- return Single.Parse(value, CultureInfo.CurrentCulture);
+ return float.Parse(value, CultureInfo.CurrentCulture);
}
- public static float ToSingle(String value, IFormatProvider provider)
+ public static float ToSingle(string value, IFormatProvider provider)
{
if (value == null)
return 0;
- return Single.Parse(value, NumberStyles.Float | NumberStyles.AllowThousands, provider);
+ return float.Parse(value, NumberStyles.Float | NumberStyles.AllowThousands, provider);
}
public static float ToSingle(bool value)
{
- return value ? Boolean.True : Boolean.False;
+ return value ? bool.True : bool.False;
}
public static float ToSingle(DateTime value)
return (double)value;
}
- public static double ToDouble(String value)
+ public static double ToDouble(string value)
{
if (value == null)
return 0;
- return Double.Parse(value, CultureInfo.CurrentCulture);
+ return double.Parse(value, CultureInfo.CurrentCulture);
}
- public static double ToDouble(String value, IFormatProvider provider)
+ public static double ToDouble(string value, IFormatProvider provider)
{
if (value == null)
return 0;
- return Double.Parse(value, NumberStyles.Float | NumberStyles.AllowThousands, provider);
+ return double.Parse(value, NumberStyles.Float | NumberStyles.AllowThousands, provider);
}
public static double ToDouble(bool value)
{
- return value ? Boolean.True : Boolean.False;
+ return value ? bool.True : bool.False;
}
public static double ToDouble(DateTime value)
return (decimal)value;
}
- public static decimal ToDecimal(String value)
+ public static decimal ToDecimal(string value)
{
if (value == null)
return 0m;
- return Decimal.Parse(value, CultureInfo.CurrentCulture);
+ return decimal.Parse(value, CultureInfo.CurrentCulture);
}
- public static Decimal ToDecimal(String value, IFormatProvider provider)
+ public static decimal ToDecimal(string value, IFormatProvider provider)
{
if (value == null)
return 0m;
- return Decimal.Parse(value, NumberStyles.Number, provider);
+ return decimal.Parse(value, NumberStyles.Number, provider);
}
public static decimal ToDecimal(decimal value)
public static decimal ToDecimal(bool value)
{
- return value ? Boolean.True : Boolean.False;
+ return value ? bool.True : bool.False;
}
public static decimal ToDecimal(DateTime value)
return value == null ? DateTime.MinValue : ((IConvertible)value).ToDateTime(provider);
}
- public static DateTime ToDateTime(String value)
+ public static DateTime ToDateTime(string value)
{
if (value == null)
return new DateTime(0);
return DateTime.Parse(value, CultureInfo.CurrentCulture);
}
- public static DateTime ToDateTime(String value, IFormatProvider provider)
+ public static DateTime ToDateTime(string value, IFormatProvider provider)
{
if (value == null)
return new DateTime(0);
// Conversions to String
- public static string ToString(Object value)
+ public static string ToString(object value)
{
return ToString(value, null);
}
- public static string ToString(Object value, IFormatProvider provider)
+ public static string ToString(object value, IFormatProvider provider)
{
IConvertible ic = value as IConvertible;
if (ic != null)
public static string ToString(char value)
{
- return Char.ToString(value);
+ return char.ToString(value);
}
public static string ToString(char value, IFormatProvider provider)
return value.ToString(CultureInfo.CurrentCulture);
}
- public static string ToString(Decimal value, IFormatProvider provider)
+ public static string ToString(decimal value, IFormatProvider provider)
{
return value.ToString(provider);
}
return value.ToString(provider);
}
- public static String ToString(String value)
+ public static string ToString(string value)
{
return value;
}
- public static String ToString(String value, IFormatProvider provider)
+ public static string ToString(string value, IFormatProvider provider)
{
return value; // avoid the null check
}
// be 2, 8, 10, or 16. If base is 16, the number may be preceded
// by 0x; any other leading or trailing characters cause an error.
//
- public static byte ToByte(String value, int fromBase)
+ public static byte ToByte(string value, int fromBase)
{
if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
{
}
int r = ParseNumbers.StringToInt(value.AsSpan(), fromBase, ParseNumbers.IsTight | ParseNumbers.TreatAsUnsigned);
- if (r < Byte.MinValue || r > Byte.MaxValue)
+ if (r < byte.MinValue || r > byte.MaxValue)
ThrowByteOverflowException();
return (byte)r;
}
// by 0x; any other leading or trailing characters cause an error.
//
[CLSCompliant(false)]
- public static sbyte ToSByte(String value, int fromBase)
+ public static sbyte ToSByte(string value, int fromBase)
{
if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
{
}
int r = ParseNumbers.StringToInt(value.AsSpan(), fromBase, ParseNumbers.IsTight | ParseNumbers.TreatAsI1);
- if (fromBase != 10 && r <= Byte.MaxValue)
+ if (fromBase != 10 && r <= byte.MaxValue)
return (sbyte)r;
- if (r < SByte.MinValue || r > SByte.MaxValue)
+ if (r < sbyte.MinValue || r > sbyte.MaxValue)
ThrowSByteOverflowException();
return (sbyte)r;
}
// be 2, 8, 10, or 16. If fromBase is 16, the number may be preceded
// by 0x; any other leading or trailing characters cause an error.
//
- public static short ToInt16(String value, int fromBase)
+ public static short ToInt16(string value, int fromBase)
{
if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
{
}
int r = ParseNumbers.StringToInt(value.AsSpan(), fromBase, ParseNumbers.IsTight | ParseNumbers.TreatAsI2);
- if (fromBase != 10 && r <= UInt16.MaxValue)
+ if (fromBase != 10 && r <= ushort.MaxValue)
return (short)r;
- if (r < Int16.MinValue || r > Int16.MaxValue)
+ if (r < short.MinValue || r > short.MaxValue)
ThrowInt16OverflowException();
return (short)r;
}
// by 0x; any other leading or trailing characters cause an error.
//
[CLSCompliant(false)]
- public static ushort ToUInt16(String value, int fromBase)
+ public static ushort ToUInt16(string value, int fromBase)
{
if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
{
}
int r = ParseNumbers.StringToInt(value.AsSpan(), fromBase, ParseNumbers.IsTight | ParseNumbers.TreatAsUnsigned);
- if (r < UInt16.MinValue || r > UInt16.MaxValue)
+ if (r < ushort.MinValue || r > ushort.MaxValue)
ThrowUInt16OverflowException();
return (ushort)r;
}
// be 2, 8, 10, or 16. If fromBase is 16, the number may be preceded
// by 0x; any other leading or trailing characters cause an error.
//
- public static int ToInt32(String value, int fromBase)
+ public static int ToInt32(string value, int fromBase)
{
if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
{
// by 0x; any other leading or trailing characters cause an error.
//
[CLSCompliant(false)]
- public static uint ToUInt32(String value, int fromBase)
+ public static uint ToUInt32(string value, int fromBase)
{
if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
{
// be 2, 8, 10, or 16. If fromBase is 16, the number may be preceded
// by 0x; any other leading or trailing characters cause an error.
//
- public static long ToInt64(String value, int fromBase)
+ public static long ToInt64(string value, int fromBase)
{
if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
{
// by 0x; any other leading or trailing characters cause an error.
//
[CLSCompliant(false)]
- public static ulong ToUInt64(String value, int fromBase)
+ public static ulong ToUInt64(string value, int fromBase)
{
if (fromBase != 2 && fromBase != 8 && fromBase != 10 && fromBase != 16)
{
}
// Convert the byte value to a string in base fromBase
- public static String ToString(byte value, int toBase)
+ public static string ToString(byte value, int toBase)
{
if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16)
{
}
// Convert the Int16 value to a string in base fromBase
- public static String ToString(short value, int toBase)
+ public static string ToString(short value, int toBase)
{
if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16)
{
}
// Convert the Int32 value to a string in base toBase
- public static String ToString(int value, int toBase)
+ public static string ToString(int value, int toBase)
{
if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16)
{
}
// Convert the Int64 value to a string in base toBase
- public static String ToString(long value, int toBase)
+ public static string ToString(long value, int toBase)
{
if (toBase != 2 && toBase != 8 && toBase != 10 && toBase != 16)
{
return ParseNumbers.LongToString(value, toBase, -1, ' ', 0);
}
- public static String ToBase64String(byte[] inArray)
+ public static string ToBase64String(byte[] inArray)
{
if (inArray == null)
{
return ToBase64String(new ReadOnlySpan<byte>(inArray), Base64FormattingOptions.None);
}
- public static String ToBase64String(byte[] inArray, Base64FormattingOptions options)
+ public static string ToBase64String(byte[] inArray, Base64FormattingOptions options)
{
if (inArray == null)
{
return ToBase64String(new ReadOnlySpan<byte>(inArray), options);
}
- public static String ToBase64String(byte[] inArray, int offset, int length)
+ public static string ToBase64String(byte[] inArray, int offset, int length)
{
return ToBase64String(inArray, offset, length, Base64FormattingOptions.None);
}
- public static String ToBase64String(byte[] inArray, int offset, int length, Base64FormattingOptions options)
+ public static string ToBase64String(byte[] inArray, int offset, int length, Base64FormattingOptions options)
{
if (inArray == null)
throw new ArgumentNullException(nameof(inArray));
/// </summary>
/// <param name="s">The string to convert</param>
/// <returns>The array of bytes represented by the specified Base64 string.</returns>
- public static Byte[] FromBase64String(String s)
+ public static byte[] FromBase64String(string s)
{
// "s" is an unfortunate parameter name, but we need to keep it for backward compat.
unsafe
{
- fixed (Char* sPtr = s)
+ fixed (char* sPtr = s)
{
return FromBase64CharPtr(sPtr, s.Length);
}
/// <param name="offset">A position within the input array.</param>
/// <param name="length">Number of element to convert.</param>
/// <returns>The array of bytes represented by the specified Base64 encoding characters.</returns>
- public static Byte[] FromBase64CharArray(Char[] inArray, Int32 offset, Int32 length)
+ public static byte[] FromBase64CharArray(char[] inArray, int offset, int length)
{
if (inArray == null)
throw new ArgumentNullException(nameof(inArray));
unsafe
{
- fixed (Char* inArrayPtr = &inArray[0])
+ fixed (char* inArrayPtr = &inArray[0])
{
return FromBase64CharPtr(inArrayPtr + offset, length);
}
/// <param name="inputPtr">Pointer to the first input char</param>
/// <param name="inputLength">Number of input chars</param>
/// <returns></returns>
- private static unsafe Byte[] FromBase64CharPtr(Char* inputPtr, Int32 inputLength)
+ private static unsafe byte[] FromBase64CharPtr(char* inputPtr, int inputLength)
{
// The validity of parameters much be checked by callers, thus we are Critical here.
// Otherwise we would be rejecting input such as "abc= ":
while (inputLength > 0)
{
- Int32 lastChar = inputPtr[inputLength - 1];
- if (lastChar != (Int32)' ' && lastChar != (Int32)'\n' && lastChar != (Int32)'\r' && lastChar != (Int32)'\t')
+ int lastChar = inputPtr[inputLength - 1];
+ if (lastChar != (int)' ' && lastChar != (int)'\n' && lastChar != (int)'\r' && lastChar != (int)'\t')
break;
inputLength--;
}
// Compute the output length:
- Int32 resultLength = FromBase64_ComputeResultLength(inputPtr, inputLength);
+ int resultLength = FromBase64_ComputeResultLength(inputPtr, inputLength);
Debug.Assert(0 <= resultLength);
// It may either simply write no bytes (e.g. input = " ") or throw (e.g. input = "ab").
// Create result byte blob:
- Byte[] decodedBytes = new Byte[resultLength];
+ byte[] decodedBytes = new byte[resultLength];
// Convert Base64 chars into bytes:
if (!TryFromBase64Chars(new ReadOnlySpan<char>(inputPtr, inputLength), decodedBytes, out int _))
/// Walk the entire input counting white spaces and padding chars, then compute result length
/// based on 3 bytes per 4 chars.
/// </summary>
- private static unsafe Int32 FromBase64_ComputeResultLength(Char* inputPtr, Int32 inputLength)
+ private static unsafe int FromBase64_ComputeResultLength(char* inputPtr, int inputLength)
{
- const UInt32 intEq = (UInt32)'=';
- const UInt32 intSpace = (UInt32)' ';
+ const uint intEq = (uint)'=';
+ const uint intSpace = (uint)' ';
Debug.Assert(0 <= inputLength);
- Char* inputEndPtr = inputPtr + inputLength;
- Int32 usefulInputLength = inputLength;
- Int32 padding = 0;
+ char* inputEndPtr = inputPtr + inputLength;
+ int usefulInputLength = inputLength;
+ int padding = 0;
while (inputPtr < inputEndPtr)
{
- UInt32 c = (UInt32)(*inputPtr);
+ uint c = (uint)(*inputPtr);
inputPtr++;
// We want to be as fast as possible and filter out spaces with as few comparisons as possible.
// E.g. the offset for PST (Pacific Standard time) should be -8 * 60 * 60 * 1000 * 10000.
// (1 millisecond = 10000 ticks)
private long m_ticksOffset;
- private String m_standardName;
- private String m_daylightName;
+ private string m_standardName;
+ private string m_daylightName;
internal CurrentSystemTimeZone()
{
m_daylightName = local.DaylightName;
}
- public override String StandardName
+ public override string StandardName
{
get
{
}
}
- public override String DaylightName
+ public override string DaylightName
{
get
{
}
}
- internal long GetUtcOffsetFromUniversalTime(DateTime time, ref Boolean isAmbiguousLocalDst)
+ internal long GetUtcOffsetFromUniversalTime(DateTime time, ref bool isAmbiguousLocalDst)
{
// Get the daylight changes for the year of the specified time.
TimeSpan offset = new TimeSpan(m_ticksOffset);
ambiguousEnd = startTime - daylightTime.Delta;
}
- Boolean isDst = false;
+ bool isDst = false;
if (startTime > endTime)
{
// In southern hemisphere, the daylight saving time starts later in the year, and ends in the beginning of next year.
{
return time;
}
- Boolean isAmbiguousLocalDst = false;
- Int64 offset = GetUtcOffsetFromUniversalTime(time, ref isAmbiguousLocalDst);
+ bool isAmbiguousLocalDst = false;
+ long offset = GetUtcOffsetFromUniversalTime(time, ref isAmbiguousLocalDst);
long tick = time.Ticks + offset;
if (tick > DateTime.MaxTicks)
{
private DaylightTime GetCachedDaylightChanges(int year)
{
- Object objYear = (Object)year;
+ object objYear = (object)year;
if (!m_CachedDaylightChanges.Contains(objYear))
{
HResult = HResults.COR_E_DATAMISALIGNED;
}
- public DataMisalignedException(String message)
+ public DataMisalignedException(string message)
: base(message)
{
HResult = HResults.COR_E_DATAMISALIGNED;
}
- public DataMisalignedException(String message, Exception innerException)
+ public DataMisalignedException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_DATAMISALIGNED;
public static readonly DateTime MaxValue = new DateTime(MaxTicks, DateTimeKind.Unspecified);
public static readonly DateTime UnixEpoch = new DateTime(UnixEpochTicks, DateTimeKind.Utc);
- private const UInt64 TicksMask = 0x3FFFFFFFFFFFFFFF;
- private const UInt64 FlagsMask = 0xC000000000000000;
- private const UInt64 LocalMask = 0x8000000000000000;
- private const Int64 TicksCeiling = 0x4000000000000000;
- private const UInt64 KindUnspecified = 0x0000000000000000;
- private const UInt64 KindUtc = 0x4000000000000000;
- private const UInt64 KindLocal = 0x8000000000000000;
- private const UInt64 KindLocalAmbiguousDst = 0xC000000000000000;
- private const Int32 KindShift = 62;
-
- private const String TicksField = "ticks"; // Do not rename (binary serialization)
- private const String DateDataField = "dateData"; // Do not rename (binary serialization)
+ private const ulong TicksMask = 0x3FFFFFFFFFFFFFFF;
+ private const ulong FlagsMask = 0xC000000000000000;
+ private const ulong LocalMask = 0x8000000000000000;
+ private const long TicksCeiling = 0x4000000000000000;
+ private const ulong KindUnspecified = 0x0000000000000000;
+ private const ulong KindUtc = 0x4000000000000000;
+ private const ulong KindLocal = 0x8000000000000000;
+ private const ulong KindLocalAmbiguousDst = 0xC000000000000000;
+ private const int KindShift = 62;
+
+ private const string TicksField = "ticks"; // Do not rename (binary serialization)
+ private const string DateDataField = "dateData"; // Do not rename (binary serialization)
// The data is stored as an unsigned 64-bit integer
// Bits 01-62: The value of 100-nanosecond ticks where 0 represents 1/1/0001 12:00am, up until the value
// savings time hour and it is in daylight savings time. This allows distinction of these
// otherwise ambiguous local times and prevents data loss when round tripping from Local to
// UTC time.
- private readonly UInt64 _dateData;
+ private readonly ulong _dateData;
// Constructs a DateTime from a tick count. The ticks
// argument specifies the date as the number of 100-nanosecond intervals
{
if (ticks < MinTicks || ticks > MaxTicks)
throw new ArgumentOutOfRangeException(nameof(ticks), SR.ArgumentOutOfRange_DateTimeBadTicks);
- _dateData = (UInt64)ticks;
+ _dateData = (ulong)ticks;
}
- private DateTime(UInt64 dateData)
+ private DateTime(ulong dateData)
{
this._dateData = dateData;
}
{
throw new ArgumentException(SR.Argument_InvalidDateTimeKind, nameof(kind));
}
- _dateData = ((UInt64)ticks | ((UInt64)kind << KindShift));
+ _dateData = ((ulong)ticks | ((ulong)kind << KindShift));
}
- internal DateTime(long ticks, DateTimeKind kind, Boolean isAmbiguousDst)
+ internal DateTime(long ticks, DateTimeKind kind, bool isAmbiguousDst)
{
if (ticks < MinTicks || ticks > MaxTicks)
{
throw new ArgumentOutOfRangeException(nameof(ticks), SR.ArgumentOutOfRange_DateTimeBadTicks);
}
Debug.Assert(kind == DateTimeKind.Local, "Internal Constructor is for local times only");
- _dateData = ((UInt64)ticks | (isAmbiguousDst ? KindLocalAmbiguousDst : KindLocal));
+ _dateData = ((ulong)ticks | (isAmbiguousDst ? KindLocalAmbiguousDst : KindLocal));
}
// Constructs a DateTime from a given year, month, and day. The
//
public DateTime(int year, int month, int day)
{
- _dateData = (UInt64)DateToTicks(year, month, day);
+ _dateData = (ulong)DateToTicks(year, month, day);
}
// Constructs a DateTime from a given year, month, and day for
//
public DateTime(int year, int month, int day, int hour, int minute, int second)
{
- _dateData = (UInt64)(DateToTicks(year, month, day) + TimeToTicks(hour, minute, second));
+ _dateData = (ulong)(DateToTicks(year, month, day) + TimeToTicks(hour, minute, second));
}
public DateTime(int year, int month, int day, int hour, int minute, int second, DateTimeKind kind)
{
throw new ArgumentException(SR.Argument_InvalidDateTimeKind, nameof(kind));
}
- Int64 ticks = DateToTicks(year, month, day) + TimeToTicks(hour, minute, second);
- _dateData = ((UInt64)ticks | ((UInt64)kind << KindShift));
+ long ticks = DateToTicks(year, month, day) + TimeToTicks(hour, minute, second);
+ _dateData = ((ulong)ticks | ((ulong)kind << KindShift));
}
// Constructs a DateTime from a given year, month, day, hour,
{
if (calendar == null)
throw new ArgumentNullException(nameof(calendar));
- _dateData = (UInt64)calendar.ToDateTime(year, month, day, hour, minute, second, 0).Ticks;
+ _dateData = (ulong)calendar.ToDateTime(year, month, day, hour, minute, second, 0).Ticks;
}
// Constructs a DateTime from a given year, month, day, hour,
{
throw new ArgumentOutOfRangeException(nameof(millisecond), SR.Format(SR.ArgumentOutOfRange_Range, 0, MillisPerSecond - 1));
}
- Int64 ticks = DateToTicks(year, month, day) + TimeToTicks(hour, minute, second);
+ long ticks = DateToTicks(year, month, day) + TimeToTicks(hour, minute, second);
ticks += millisecond * TicksPerMillisecond;
if (ticks < MinTicks || ticks > MaxTicks)
throw new ArgumentException(SR.Arg_DateTimeRange);
- _dateData = (UInt64)ticks;
+ _dateData = (ulong)ticks;
}
public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, DateTimeKind kind)
{
throw new ArgumentException(SR.Argument_InvalidDateTimeKind, nameof(kind));
}
- Int64 ticks = DateToTicks(year, month, day) + TimeToTicks(hour, minute, second);
+ long ticks = DateToTicks(year, month, day) + TimeToTicks(hour, minute, second);
ticks += millisecond * TicksPerMillisecond;
if (ticks < MinTicks || ticks > MaxTicks)
throw new ArgumentException(SR.Arg_DateTimeRange);
- _dateData = ((UInt64)ticks | ((UInt64)kind << KindShift));
+ _dateData = ((ulong)ticks | ((ulong)kind << KindShift));
}
// Constructs a DateTime from a given year, month, day, hour,
{
throw new ArgumentOutOfRangeException(nameof(millisecond), SR.Format(SR.ArgumentOutOfRange_Range, 0, MillisPerSecond - 1));
}
- Int64 ticks = calendar.ToDateTime(year, month, day, hour, minute, second, 0).Ticks;
+ long ticks = calendar.ToDateTime(year, month, day, hour, minute, second, 0).Ticks;
ticks += millisecond * TicksPerMillisecond;
if (ticks < MinTicks || ticks > MaxTicks)
throw new ArgumentException(SR.Arg_DateTimeRange);
- _dateData = (UInt64)ticks;
+ _dateData = (ulong)ticks;
}
public DateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar, DateTimeKind kind)
{
throw new ArgumentException(SR.Argument_InvalidDateTimeKind, nameof(kind));
}
- Int64 ticks = calendar.ToDateTime(year, month, day, hour, minute, second, 0).Ticks;
+ long ticks = calendar.ToDateTime(year, month, day, hour, minute, second, 0).Ticks;
ticks += millisecond * TicksPerMillisecond;
if (ticks < MinTicks || ticks > MaxTicks)
throw new ArgumentException(SR.Arg_DateTimeRange);
- _dateData = ((UInt64)ticks | ((UInt64)kind << KindShift));
+ _dateData = ((ulong)ticks | ((ulong)kind << KindShift));
}
private DateTime(SerializationInfo info, StreamingContext context)
if (info == null)
throw new ArgumentNullException(nameof(info));
- Boolean foundTicks = false;
- Boolean foundDateData = false;
- Int64 serializedTicks = 0;
- UInt64 serializedDateData = 0;
+ bool foundTicks = false;
+ bool foundDateData = false;
+ long serializedTicks = 0;
+ ulong serializedDateData = 0;
// Get the data
}
else if (foundTicks)
{
- _dateData = (UInt64)serializedTicks;
+ _dateData = (ulong)serializedTicks;
}
else
{
throw new SerializationException(SR.Serialization_MissingDateTimeData);
}
- Int64 ticks = InternalTicks;
+ long ticks = InternalTicks;
if (ticks < MinTicks || ticks > MaxTicks)
{
throw new SerializationException(SR.Serialization_DateTimeTicksOutOfRange);
- internal Int64 InternalTicks
+ internal long InternalTicks
{
get
{
- return (Int64)(_dateData & TicksMask);
+ return (long)(_dateData & TicksMask);
}
}
- private UInt64 InternalKind
+ private ulong InternalKind
{
get
{
}
int days = DaysInMonth(y, m);
if (d > days) d = days;
- return new DateTime((UInt64)(DateToTicks(y, m, d) + InternalTicks % TicksPerDay) | InternalKind);
+ return new DateTime((ulong)(DateToTicks(y, m, d) + InternalTicks % TicksPerDay) | InternalKind);
}
// Returns the DateTime resulting from adding a fractional number of
{
throw new ArgumentOutOfRangeException(nameof(value), SR.ArgumentOutOfRange_DateArithmetic);
}
- return new DateTime((UInt64)(ticks + value) | InternalKind);
+ return new DateTime((ulong)(ticks + value) | InternalKind);
}
// Returns the DateTime resulting from adding the given number of
//
public static int Compare(DateTime t1, DateTime t2)
{
- Int64 ticks1 = t1.InternalTicks;
- Int64 ticks2 = t2.InternalTicks;
+ long ticks1 = t1.InternalTicks;
+ long ticks2 = t2.InternalTicks;
if (ticks1 > ticks2) return 1;
if (ticks1 < ticks2) return -1;
return 0;
// occurs. Null is considered less than any instance.
//
// Returns a value less than zero if this object
- public int CompareTo(Object value)
+ public int CompareTo(object value)
{
if (value == null) return 1;
if (!(value is DateTime))
// is equal to the value of this DateTime. Returns false
// otherwise.
//
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
if (value is DateTime)
{
return t1.InternalTicks == t2.InternalTicks;
}
- public static DateTime FromBinary(Int64 dateData)
+ public static DateTime FromBinary(long dateData)
{
- if ((dateData & (unchecked((Int64)LocalMask))) != 0)
+ if ((dateData & (unchecked((long)LocalMask))) != 0)
{
// Local times need to be adjusted as you move from one time zone to another,
// just as they are when serializing in text. As such the format for local times
// changes to store the ticks of the UTC time, but with flags that look like a
// local date.
- Int64 ticks = dateData & (unchecked((Int64)TicksMask));
+ long ticks = dateData & (unchecked((long)TicksMask));
// Negative ticks are stored in the top part of the range and should be converted back into a negative number
if (ticks > TicksCeiling - TicksPerDay)
{
}
// Convert the ticks back to local. If the UTC ticks are out of range, we need to default to
// the UTC offset from MinValue and MaxValue to be consistent with Parse.
- Boolean isAmbiguousLocalDst = false;
- Int64 offsetTicks;
+ bool isAmbiguousLocalDst = false;
+ long offsetTicks;
if (ticks < MinTicks)
{
offsetTicks = TimeZoneInfo.GetLocalUtcOffset(DateTime.MinValue, TimeZoneInfoOptions.NoThrowOnInvalidTime).Ticks;
// Because the ticks conversion between UTC and local is lossy, we need to capture whether the
// time is in a repeated hour so that it can be passed to the DateTime constructor.
DateTime utcDt = new DateTime(ticks, DateTimeKind.Utc);
- Boolean isDaylightSavings = false;
+ bool isDaylightSavings = false;
offsetTicks = TimeZoneInfo.GetUtcOffsetFromUtc(utcDt, TimeZoneInfo.Local, out isDaylightSavings, out isAmbiguousLocalDst).Ticks;
}
ticks += offsetTicks;
// A version of ToBinary that uses the real representation and does not adjust local times. This is needed for
// scenarios where the serialized data must maintain compatibility
- internal static DateTime FromBinaryRaw(Int64 dateData)
+ internal static DateTime FromBinaryRaw(long dateData)
{
- Int64 ticks = dateData & (Int64)TicksMask;
+ long ticks = dateData & (long)TicksMask;
if (ticks < MinTicks || ticks > MaxTicks)
throw new ArgumentException(SR.Argument_DateTimeBadBinaryData, nameof(dateData));
- return new DateTime((UInt64)dateData);
+ return new DateTime((ulong)dateData);
}
// Creates a DateTime from a Windows filetime. A Windows filetime is
info.AddValue(DateDataField, _dateData);
}
- public Boolean IsDaylightSavingTime()
+ public bool IsDaylightSavingTime()
{
if (Kind == DateTimeKind.Utc)
{
return new DateTime(value.InternalTicks, kind);
}
- public Int64 ToBinary()
+ public long ToBinary()
{
if (Kind == DateTimeKind.Local)
{
// end of the maximum range, and values just below minimum value are stored
// at the end of the ticks area, just below 2^62.
TimeSpan offset = TimeZoneInfo.GetLocalUtcOffset(this, TimeZoneInfoOptions.NoThrowOnInvalidTime);
- Int64 ticks = Ticks;
- Int64 storedTicks = ticks - offset.Ticks;
+ long ticks = Ticks;
+ long storedTicks = ticks - offset.Ticks;
if (storedTicks < 0)
{
storedTicks = TicksCeiling + storedTicks;
}
- return storedTicks | (unchecked((Int64)LocalMask));
+ return storedTicks | (unchecked((long)LocalMask));
}
else
{
- return (Int64)_dateData;
+ return (long)_dateData;
}
}
{
get
{
- Int64 ticks = InternalTicks;
- return new DateTime((UInt64)(ticks - ticks % TicksPerDay) | InternalKind);
+ long ticks = InternalTicks;
+ return new DateTime((ulong)(ticks - ticks % TicksPerDay) | InternalKind);
}
}
// to compute the year, day-of-year, month, or day part.
private int GetDatePart(int part)
{
- Int64 ticks = InternalTicks;
+ long ticks = InternalTicks;
// n = number of days since 1/1/0001
int n = (int)(ticks / TicksPerDay);
// y400 = number of whole 400-year periods since 1/1/0001
// are needed rather than redoing the computations for each.
internal void GetDatePart(out int year, out int month, out int day)
{
- Int64 ticks = InternalTicks;
+ long ticks = InternalTicks;
// n = number of days since 1/1/0001
int n = (int)(ticks / TicksPerDay);
// y400 = number of whole 400-year periods since 1/1/0001
//
public override int GetHashCode()
{
- Int64 ticks = InternalTicks;
+ long ticks = InternalTicks;
return unchecked((int)ticks) ^ (int)(ticks >> 32);
}
}
}
- internal Boolean IsAmbiguousDaylightSavingTime()
+ internal bool IsAmbiguousDaylightSavingTime()
{
return (InternalKind == KindLocalAmbiguousDst);
}
get
{
DateTime utc = UtcNow;
- Boolean isAmbiguousLocalDst = false;
- Int64 offset = TimeZoneInfo.GetDateTimeNowUtcOffsetFromUtc(utc, out isAmbiguousLocalDst).Ticks;
+ bool isAmbiguousLocalDst = false;
+ long offset = TimeZoneInfo.GetDateTimeNowUtcOffsetFromUtc(utc, out isAmbiguousLocalDst).Ticks;
long tick = utc.Ticks + offset;
if (tick > DateTime.MaxTicks)
{
// date and optionally a time in a culture-specific or universal format.
// Leading and trailing whitespace characters are allowed.
//
- public static DateTime Parse(String s)
+ public static DateTime Parse(string s)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return (DateTimeParse.Parse(s, DateTimeFormatInfo.CurrentInfo, DateTimeStyles.None));
// date and optionally a time in a culture-specific or universal format.
// Leading and trailing whitespace characters are allowed.
//
- public static DateTime Parse(String s, IFormatProvider provider)
+ public static DateTime Parse(string s, IFormatProvider provider)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return (DateTimeParse.Parse(s, DateTimeFormatInfo.GetInstance(provider), DateTimeStyles.None));
}
- public static DateTime Parse(String s, IFormatProvider provider, DateTimeStyles styles)
+ public static DateTime Parse(string s, IFormatProvider provider, DateTimeStyles styles)
{
DateTimeFormatInfo.ValidateStyles(styles, nameof(styles));
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
// date and optionally a time in a culture-specific or universal format.
// Leading and trailing whitespace characters are allowed.
//
- public static DateTime ParseExact(String s, String format, IFormatProvider provider)
+ public static DateTime ParseExact(string s, string format, IFormatProvider provider)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
if (format == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.format);
// date and optionally a time in a culture-specific or universal format.
// Leading and trailing whitespace characters are allowed.
//
- public static DateTime ParseExact(String s, String format, IFormatProvider provider, DateTimeStyles style)
+ public static DateTime ParseExact(string s, string format, IFormatProvider provider, DateTimeStyles style)
{
DateTimeFormatInfo.ValidateStyles(style, nameof(style));
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return DateTimeParse.ParseExact(s, format, DateTimeFormatInfo.GetInstance(provider), style);
}
- public static DateTime ParseExact(String s, String[] formats, IFormatProvider provider, DateTimeStyles style)
+ public static DateTime ParseExact(string s, string[] formats, IFormatProvider provider, DateTimeStyles style)
{
DateTimeFormatInfo.ValidateStyles(style, nameof(style));
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
{
throw new ArgumentOutOfRangeException(nameof(value), SR.ArgumentOutOfRange_DateArithmetic);
}
- return new DateTime((UInt64)(ticks - valueTicks) | InternalKind);
+ return new DateTime((ulong)(ticks - valueTicks) | InternalKind);
}
// This function is duplicated in COMDateTime.cpp
{
return this;
}
- Boolean isDaylightSavings = false;
- Boolean isAmbiguousLocalDst = false;
- Int64 offset = TimeZoneInfo.GetUtcOffsetFromUtc(this, TimeZoneInfo.Local, out isDaylightSavings, out isAmbiguousLocalDst).Ticks;
+ bool isDaylightSavings = false;
+ bool isAmbiguousLocalDst = false;
+ long offset = TimeZoneInfo.GetUtcOffsetFromUtc(this, TimeZoneInfo.Local, out isDaylightSavings, out isAmbiguousLocalDst).Ticks;
long tick = Ticks + offset;
if (tick > DateTime.MaxTicks)
{
return new DateTime(tick, DateTimeKind.Local, isAmbiguousLocalDst);
}
- public String ToLongDateString()
+ public string ToLongDateString()
{
return DateTimeFormat.Format(this, "D", null);
}
- public String ToLongTimeString()
+ public string ToLongTimeString()
{
return DateTimeFormat.Format(this, "T", null);
}
- public String ToShortDateString()
+ public string ToShortDateString()
{
return DateTimeFormat.Format(this, "d", null);
}
- public String ToShortTimeString()
+ public string ToShortTimeString()
{
return DateTimeFormat.Format(this, "t", null);
}
- public override String ToString()
+ public override string ToString()
{
return DateTimeFormat.Format(this, null, null);
}
- public String ToString(String format)
+ public string ToString(string format)
{
return DateTimeFormat.Format(this, format, null);
}
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
return DateTimeFormat.Format(this, null, provider);
}
- public String ToString(String format, IFormatProvider provider)
+ public string ToString(string format, IFormatProvider provider)
{
return DateTimeFormat.Format(this, format, provider);
}
return TimeZoneInfo.ConvertTimeToUtc(this, TimeZoneInfoOptions.NoThrowOnInvalidTime);
}
- public static Boolean TryParse(String s, out DateTime result)
+ public static bool TryParse(string s, out DateTime result)
{
if (s == null)
{
return DateTimeParse.TryParse(s, DateTimeFormatInfo.CurrentInfo, DateTimeStyles.None, out result);
}
- public static Boolean TryParse(String s, IFormatProvider provider, DateTimeStyles styles, out DateTime result)
+ public static bool TryParse(string s, IFormatProvider provider, DateTimeStyles styles, out DateTime result)
{
DateTimeFormatInfo.ValidateStyles(styles, nameof(styles));
return DateTimeParse.TryParse(s, DateTimeFormatInfo.GetInstance(provider), styles, out result);
}
- public static Boolean TryParseExact(String s, String format, IFormatProvider provider, DateTimeStyles style, out DateTime result)
+ public static bool TryParseExact(string s, string format, IFormatProvider provider, DateTimeStyles style, out DateTime result)
{
DateTimeFormatInfo.ValidateStyles(style, nameof(style));
return DateTimeParse.TryParseExact(s, format, DateTimeFormatInfo.GetInstance(provider), style, out result);
}
- public static Boolean TryParseExact(String s, String[] formats, IFormatProvider provider, DateTimeStyles style, out DateTime result)
+ public static bool TryParseExact(string s, string[] formats, IFormatProvider provider, DateTimeStyles style, out DateTime result)
{
DateTimeFormatInfo.ValidateStyles(style, nameof(style));
{
throw new ArgumentOutOfRangeException(nameof(t), SR.ArgumentOutOfRange_DateArithmetic);
}
- return new DateTime((UInt64)(ticks + valueTicks) | d.InternalKind);
+ return new DateTime((ulong)(ticks + valueTicks) | d.InternalKind);
}
public static DateTime operator -(DateTime d, TimeSpan t)
{
throw new ArgumentOutOfRangeException(nameof(t), SR.ArgumentOutOfRange_DateArithmetic);
}
- return new DateTime((UInt64)(ticks - valueTicks) | d.InternalKind);
+ return new DateTime((ulong)(ticks - valueTicks) | d.InternalKind);
}
public static TimeSpan operator -(DateTime d1, DateTime d2)
// Returns a string array containing all of the known date and time options for the
// current culture. The strings returned are properly formatted date and
// time strings for the current instance of DateTime.
- public String[] GetDateTimeFormats()
+ public string[] GetDateTimeFormats()
{
return (GetDateTimeFormats(CultureInfo.CurrentCulture));
}
// Returns a string array containing all of the known date and time options for the
// using the information provided by IFormatProvider. The strings returned are properly formatted date and
// time strings for the current instance of DateTime.
- public String[] GetDateTimeFormats(IFormatProvider provider)
+ public string[] GetDateTimeFormats(IFormatProvider provider)
{
return (DateTimeFormat.GetAllDateTimes(this, DateTimeFormatInfo.GetInstance(provider)));
}
// Returns a string array containing all of the date and time options for the
// given format format and current culture. The strings returned are properly formatted date and
// time strings for the current instance of DateTime.
- public String[] GetDateTimeFormats(char format)
+ public string[] GetDateTimeFormats(char format)
{
return (GetDateTimeFormats(format, CultureInfo.CurrentCulture));
}
// Returns a string array containing all of the date and time options for the
// given format format and given culture. The strings returned are properly formatted date and
// time strings for the current instance of DateTime.
- public String[] GetDateTimeFormats(char format, IFormatProvider provider)
+ public string[] GetDateTimeFormats(char format, IFormatProvider provider)
{
return (DateTimeFormat.GetAllDateTimes(this, format, DateTimeFormatInfo.GetInstance(provider)));
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "DateTime", "Double"));
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "DateTime", "Decimal"));
}
return this;
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
// Tries to construct a DateTime from a given year, month, day, hour,
// minute, second and millisecond.
//
- internal static Boolean TryCreate(int year, int month, int day, int hour, int minute, int second, int millisecond, out DateTime result)
+ internal static bool TryCreate(int year, int month, int day, int hour, int minute, int second, int millisecond, out DateTime result)
{
result = DateTime.MinValue;
if (year < 1 || year > 9999 || month < 1 || month > 12)
public struct DateTimeOffset : IComparable, IFormattable, IComparable<DateTimeOffset>, IEquatable<DateTimeOffset>, ISerializable, IDeserializationCallback, ISpanFormattable
{
// Constants
- internal const Int64 MaxOffset = TimeSpan.TicksPerHour * 14;
- internal const Int64 MinOffset = -MaxOffset;
+ internal const long MaxOffset = TimeSpan.TicksPerHour * 14;
+ internal const long MinOffset = -MaxOffset;
private const long UnixEpochSeconds = DateTime.UnixEpochTicks / TimeSpan.TicksPerSecond; // 62,135,596,800
private const long UnixEpochMilliseconds = DateTime.UnixEpochTicks / TimeSpan.TicksPerMillisecond; // 62,135,596,800,000
// Instance Fields
private DateTime _dateTime;
- private Int16 _offsetMinutes;
+ private short _offsetMinutes;
// Constructors
// argument must be another DateTimeOffset, or otherwise an exception
// occurs. Null is considered less than any instance.
//
- int IComparable.CompareTo(Object obj)
+ int IComparable.CompareTo(object obj)
{
if (obj == null) return 1;
if (!(obj is DateTimeOffset))
// is equal to the value of this DateTimeOffset. Returns false
// otherwise.
//
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj is DateTimeOffset)
{
// ----- SECTION: private serialization instance methods ----------------*
- void IDeserializationCallback.OnDeserialization(Object sender)
+ void IDeserializationCallback.OnDeserialization(object sender)
{
try
{
}
_dateTime = (DateTime)info.GetValue("DateTime", typeof(DateTime)); // Do not rename (binary serialization)
- _offsetMinutes = (Int16)info.GetValue("OffsetMinutes", typeof(Int16)); // Do not rename (binary serialization)
+ _offsetMinutes = (short)info.GetValue("OffsetMinutes", typeof(short)); // Do not rename (binary serialization)
}
// Returns the hash code for this DateTimeOffset.
// date and optionally a time in a culture-specific or universal format.
// Leading and trailing whitespace characters are allowed.
//
- public static DateTimeOffset Parse(String input)
+ public static DateTimeOffset Parse(string input)
{
if (input == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
// date and optionally a time in a culture-specific or universal format.
// Leading and trailing whitespace characters are allowed.
//
- public static DateTimeOffset Parse(String input, IFormatProvider formatProvider)
+ public static DateTimeOffset Parse(string input, IFormatProvider formatProvider)
{
if (input == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
return Parse(input, formatProvider, DateTimeStyles.None);
}
- public static DateTimeOffset Parse(String input, IFormatProvider formatProvider, DateTimeStyles styles)
+ public static DateTimeOffset Parse(string input, IFormatProvider formatProvider, DateTimeStyles styles)
{
styles = ValidateStyles(styles, nameof(styles));
if (input == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
// date and optionally a time in a culture-specific or universal format.
// Leading and trailing whitespace characters are allowed.
//
- public static DateTimeOffset ParseExact(String input, String format, IFormatProvider formatProvider)
+ public static DateTimeOffset ParseExact(string input, string format, IFormatProvider formatProvider)
{
if (input == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
if (format == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.format);
// date and optionally a time in a culture-specific or universal format.
// Leading and trailing whitespace characters are allowed.
//
- public static DateTimeOffset ParseExact(String input, String format, IFormatProvider formatProvider, DateTimeStyles styles)
+ public static DateTimeOffset ParseExact(string input, string format, IFormatProvider formatProvider, DateTimeStyles styles)
{
styles = ValidateStyles(styles, nameof(styles));
if (input == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
return new DateTimeOffset(dateResult.Ticks, offset);
}
- public static DateTimeOffset ParseExact(String input, String[] formats, IFormatProvider formatProvider, DateTimeStyles styles)
+ public static DateTimeOffset ParseExact(string input, string[] formats, IFormatProvider formatProvider, DateTimeStyles styles)
{
styles = ValidateStyles(styles, nameof(styles));
if (input == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
return new DateTimeOffset(UtcDateTime.ToLocalTime(throwOnOverflow));
}
- public override String ToString()
+ public override string ToString()
{
return DateTimeFormat.Format(ClockDateTime, null, null, Offset);
}
- public String ToString(String format)
+ public string ToString(string format)
{
return DateTimeFormat.Format(ClockDateTime, format, null, Offset);
}
- public String ToString(IFormatProvider formatProvider)
+ public string ToString(IFormatProvider formatProvider)
{
return DateTimeFormat.Format(ClockDateTime, null, formatProvider, Offset);
}
- public String ToString(String format, IFormatProvider formatProvider)
+ public string ToString(string format, IFormatProvider formatProvider)
{
return DateTimeFormat.Format(ClockDateTime, format, formatProvider, Offset);
}
return new DateTimeOffset(UtcDateTime);
}
- public static Boolean TryParse(String input, out DateTimeOffset result)
+ public static bool TryParse(string input, out DateTimeOffset result)
{
TimeSpan offset;
DateTime dateResult;
- Boolean parsed = DateTimeParse.TryParse(input,
+ bool parsed = DateTimeParse.TryParse(input,
DateTimeFormatInfo.CurrentInfo,
DateTimeStyles.None,
out dateResult,
return parsed;
}
- public static Boolean TryParse(String input, IFormatProvider formatProvider, DateTimeStyles styles, out DateTimeOffset result)
+ public static bool TryParse(string input, IFormatProvider formatProvider, DateTimeStyles styles, out DateTimeOffset result)
{
styles = ValidateStyles(styles, nameof(styles));
if (input == null)
TimeSpan offset;
DateTime dateResult;
- Boolean parsed = DateTimeParse.TryParse(input,
+ bool parsed = DateTimeParse.TryParse(input,
DateTimeFormatInfo.GetInstance(formatProvider),
styles,
out dateResult,
return parsed;
}
- public static Boolean TryParseExact(String input, String format, IFormatProvider formatProvider, DateTimeStyles styles,
+ public static bool TryParseExact(string input, string format, IFormatProvider formatProvider, DateTimeStyles styles,
out DateTimeOffset result)
{
styles = ValidateStyles(styles, nameof(styles));
TimeSpan offset;
DateTime dateResult;
- Boolean parsed = DateTimeParse.TryParseExact(input,
+ bool parsed = DateTimeParse.TryParseExact(input,
format,
DateTimeFormatInfo.GetInstance(formatProvider),
styles,
return parsed;
}
- public static Boolean TryParseExact(String input, String[] formats, IFormatProvider formatProvider, DateTimeStyles styles,
+ public static bool TryParseExact(string input, string[] formats, IFormatProvider formatProvider, DateTimeStyles styles,
out DateTimeOffset result)
{
styles = ValidateStyles(styles, nameof(styles));
TimeSpan offset;
DateTime dateResult;
- Boolean parsed = DateTimeParse.TryParseExactMultiple(input,
+ bool parsed = DateTimeParse.TryParseExactMultiple(input,
formats,
DateTimeFormatInfo.GetInstance(formatProvider),
styles,
}
// Ensures the TimeSpan is valid to go in a DateTimeOffset.
- private static Int16 ValidateOffset(TimeSpan offset)
+ private static short ValidateOffset(TimeSpan offset)
{
- Int64 ticks = offset.Ticks;
+ long ticks = offset.Ticks;
if (ticks % TimeSpan.TicksPerMinute != 0)
{
throw new ArgumentException(SR.Argument_OffsetPrecision, nameof(offset));
{
throw new ArgumentOutOfRangeException(nameof(offset), SR.Argument_OffsetOutOfRange);
}
- return (Int16)(offset.Ticks / TimeSpan.TicksPerMinute);
+ return (short)(offset.Ticks / TimeSpan.TicksPerMinute);
}
// Ensures that the time and offset are in range.
Debug.Assert(offset.Ticks >= MinOffset && offset.Ticks <= MaxOffset, "Offset not validated.");
// This operation cannot overflow because offset should have already been validated to be within
- // 14 hours and the DateTime instance is more than that distance from the boundaries of Int64.
- Int64 utcTicks = dateTime.Ticks - offset.Ticks;
+ // 14 hours and the DateTime instance is more than that distance from the boundaries of long.
+ long utcTicks = dateTime.Ticks - offset.Ticks;
if (utcTicks < DateTime.MinTicks || utcTicks > DateTime.MaxTicks)
{
throw new ArgumentOutOfRangeException(nameof(offset), SR.Argument_UTCOutOfRange);
return new DateTime(utcTicks, DateTimeKind.Unspecified);
}
- private static DateTimeStyles ValidateStyles(DateTimeStyles style, String parameterName)
+ private static DateTimeStyles ValidateStyles(DateTimeStyles style, string parameterName)
{
if ((style & DateTimeFormatInfo.InvalidDateTimeStyles) != 0)
{
// Fail in order to avoid anyone catching an exception and masking
// an assert failure.
DebugAssertException ex;
- if (message == String.Empty)
+ if (message == string.Empty)
{
ex = new DebugAssertException(stackTrace);
}
- else if (detailMessage == String.Empty)
+ else if (detailMessage == string.Empty)
{
ex = new DebugAssertException(message, stackTrace);
}
*uintptr = (uint)data;
dataDescriptor->Ptr = (ulong)uintptr;
}
- else if (data is UInt64)
+ else if (data is ulong)
{
dataDescriptor->Size = (uint)sizeof(ulong);
- UInt64* ulongptr = (ulong*)dataBuffer;
+ ulong* ulongptr = (ulong*)dataBuffer;
*ulongptr = (ulong)data;
dataDescriptor->Ptr = (ulong)ulongptr;
}
}
// Define an EventPipeEvent handle.
- unsafe IntPtr IEventProvider.DefineEventHandle(uint eventID, string eventName, Int64 keywords, uint eventVersion, uint level, byte *pMetadata, uint metadataLength)
+ unsafe IntPtr IEventProvider.DefineEventHandle(uint eventID, string eventName, long keywords, uint eventVersion, uint level, byte *pMetadata, uint metadataLength)
{
throw new System.NotSupportedException();
}
}
// Define an EventPipeEvent handle.
- unsafe IntPtr IEventProvider.DefineEventHandle(uint eventID, string eventName, Int64 keywords, uint eventVersion, uint level, byte *pMetadata, uint metadataLength)
+ unsafe IntPtr IEventProvider.DefineEventHandle(uint eventID, string eventName, long keywords, uint eventVersion, uint level, byte *pMetadata, uint metadataLength)
{
return IntPtr.Zero;
}
uint metadataLength = (metadata != null) ? (uint)metadata.Length : 0;
string eventName = m_eventData[i].Name;
- Int64 keywords = m_eventData[i].Descriptor.Keywords;
+ long keywords = m_eventData[i].Descriptor.Keywords;
uint eventVersion = m_eventData[i].Descriptor.Version;
uint level = m_eventData[i].Descriptor.Level;
/// <summary>
/// Gets the payload for the event.
/// </summary>
- public ReadOnlyCollection<Object> Payload { get; internal set; }
+ public ReadOnlyCollection<object> Payload { get; internal set; }
/// <summary>
/// Gets the payload argument names.
templates.Append(" length=\"").Append(name).Append("Size\"");
}
// ETW does not support 64-bit value maps, so we don't specify these as ETW maps
- if (type.IsEnum() && Enum.GetUnderlyingType(type) != typeof(UInt64) && Enum.GetUnderlyingType(type) != typeof(Int64))
+ if (type.IsEnum() && Enum.GetUnderlyingType(type) != typeof(ulong) && Enum.GetUnderlyingType(type) != typeof(long))
{
templates.Append(" map=\"").Append(type.Name).Append("\"");
if (mapsTab == null)
int leftBracket = i;
i++;
int argNum = 0;
- while (i < eventMessage.Length && Char.IsDigit(eventMessage[i]))
+ while (i < eventMessage.Length && char.IsDigit(eventMessage[i]))
{
argNum = argNum * 10 + eventMessage[i] - '0';
i++;
int EventActivityIdControl(UnsafeNativeMethods.ManifestEtw.ActivityControl ControlCode, ref Guid ActivityId);
// Define an EventPipeEvent handle.
- unsafe IntPtr DefineEventHandle(uint eventID, string eventName, Int64 keywords, uint eventVersion, uint level, byte *pMetadata, uint metadataLength);
+ unsafe IntPtr DefineEventHandle(uint eventID, string eventName, long keywords, uint eventVersion, uint level, byte *pMetadata, uint metadataLength);
}
}
public struct Scalar
{
[FieldOffset(0)]
- public Boolean AsBoolean;
+ public bool AsBoolean;
[FieldOffset(0)]
- public Byte AsByte;
+ public byte AsByte;
[FieldOffset(0)]
- public SByte AsSByte;
+ public sbyte AsSByte;
[FieldOffset(0)]
- public Char AsChar;
+ public char AsChar;
[FieldOffset(0)]
- public Int16 AsInt16;
+ public short AsInt16;
[FieldOffset(0)]
- public UInt16 AsUInt16;
+ public ushort AsUInt16;
[FieldOffset(0)]
- public Int32 AsInt32;
+ public int AsInt32;
[FieldOffset(0)]
- public UInt32 AsUInt32;
+ public uint AsUInt32;
[FieldOffset(0)]
- public Int64 AsInt64;
+ public long AsInt64;
[FieldOffset(0)]
- public UInt64 AsUInt64;
+ public ulong AsUInt64;
[FieldOffset(0)]
public IntPtr AsIntPtr;
[FieldOffset(0)]
public UIntPtr AsUIntPtr;
[FieldOffset(0)]
- public Single AsSingle;
+ public float AsSingle;
[FieldOffset(0)]
- public Double AsDouble;
+ public double AsDouble;
[FieldOffset(0)]
public Guid AsGuid;
[FieldOffset(0)]
[FieldOffset(0)]
public TimeSpan AsTimeSpan;
[FieldOffset(0)]
- public Decimal AsDecimal;
+ public decimal AsDecimal;
}
// Anything not covered by the Scalar union gets stored in this reference.
_scalarLength = scalarLength;
}
- private PropertyValue(Boolean value) : this(new Scalar() { AsBoolean = value }, sizeof(Boolean)) { }
- private PropertyValue(Byte value) : this(new Scalar() { AsByte = value }, sizeof(Byte)) { }
- private PropertyValue(SByte value) : this(new Scalar() { AsSByte = value }, sizeof(SByte)) { }
- private PropertyValue(Char value) : this(new Scalar() { AsChar = value }, sizeof(Char)) { }
- private PropertyValue(Int16 value) : this(new Scalar() { AsInt16 = value }, sizeof(Int16)) { }
- private PropertyValue(UInt16 value) : this(new Scalar() { AsUInt16 = value }, sizeof(UInt16)) { }
- private PropertyValue(Int32 value) : this(new Scalar() { AsInt32 = value }, sizeof(Int32)) { }
- private PropertyValue(UInt32 value) : this(new Scalar() { AsUInt32 = value }, sizeof(UInt32)) { }
- private PropertyValue(Int64 value) : this(new Scalar() { AsInt64 = value }, sizeof(Int64)) { }
- private PropertyValue(UInt64 value) : this(new Scalar() { AsUInt64 = value }, sizeof(UInt64)) { }
+ private PropertyValue(bool value) : this(new Scalar() { AsBoolean = value }, sizeof(bool)) { }
+ private PropertyValue(byte value) : this(new Scalar() { AsByte = value }, sizeof(byte)) { }
+ private PropertyValue(sbyte value) : this(new Scalar() { AsSByte = value }, sizeof(sbyte)) { }
+ private PropertyValue(char value) : this(new Scalar() { AsChar = value }, sizeof(char)) { }
+ private PropertyValue(short value) : this(new Scalar() { AsInt16 = value }, sizeof(short)) { }
+ private PropertyValue(ushort value) : this(new Scalar() { AsUInt16 = value }, sizeof(ushort)) { }
+ private PropertyValue(int value) : this(new Scalar() { AsInt32 = value }, sizeof(int)) { }
+ private PropertyValue(uint value) : this(new Scalar() { AsUInt32 = value }, sizeof(uint)) { }
+ private PropertyValue(long value) : this(new Scalar() { AsInt64 = value }, sizeof(long)) { }
+ private PropertyValue(ulong value) : this(new Scalar() { AsUInt64 = value }, sizeof(ulong)) { }
private PropertyValue(IntPtr value) : this(new Scalar() { AsIntPtr = value }, sizeof(IntPtr)) { }
private PropertyValue(UIntPtr value) : this(new Scalar() { AsUIntPtr = value }, sizeof(UIntPtr)) { }
- private PropertyValue(Single value) : this(new Scalar() { AsSingle = value }, sizeof(Single)) { }
- private PropertyValue(Double value) : this(new Scalar() { AsDouble = value }, sizeof(Double)) { }
+ private PropertyValue(float value) : this(new Scalar() { AsSingle = value }, sizeof(float)) { }
+ private PropertyValue(double value) : this(new Scalar() { AsDouble = value }, sizeof(double)) { }
private PropertyValue(Guid value) : this(new Scalar() { AsGuid = value }, sizeof(Guid)) { }
private PropertyValue(DateTime value) : this(new Scalar() { AsDateTime = value }, sizeof(DateTime)) { }
private PropertyValue(DateTimeOffset value) : this(new Scalar() { AsDateTimeOffset = value }, sizeof(DateTimeOffset)) { }
private PropertyValue(TimeSpan value) : this(new Scalar() { AsTimeSpan = value }, sizeof(TimeSpan)) { }
- private PropertyValue(Decimal value) : this(new Scalar() { AsDecimal = value }, sizeof(Decimal)) { }
+ private PropertyValue(decimal value) : this(new Scalar() { AsDecimal = value }, sizeof(decimal)) { }
public static Func<object, PropertyValue> GetFactory(Type type)
{
- if (type == typeof(Boolean)) return value => new PropertyValue((Boolean)value);
- if (type == typeof(Byte)) return value => new PropertyValue((Byte)value);
- if (type == typeof(SByte)) return value => new PropertyValue((SByte)value);
- if (type == typeof(Char)) return value => new PropertyValue((Char)value);
- if (type == typeof(Int16)) return value => new PropertyValue((Int16)value);
- if (type == typeof(UInt16)) return value => new PropertyValue((UInt16)value);
- if (type == typeof(Int32)) return value => new PropertyValue((Int32)value);
- if (type == typeof(UInt32)) return value => new PropertyValue((UInt32)value);
- if (type == typeof(Int64)) return value => new PropertyValue((Int64)value);
- if (type == typeof(UInt64)) return value => new PropertyValue((UInt64)value);
+ if (type == typeof(bool)) return value => new PropertyValue((bool)value);
+ if (type == typeof(byte)) return value => new PropertyValue((byte)value);
+ if (type == typeof(sbyte)) return value => new PropertyValue((sbyte)value);
+ if (type == typeof(char)) return value => new PropertyValue((char)value);
+ if (type == typeof(short)) return value => new PropertyValue((short)value);
+ if (type == typeof(ushort)) return value => new PropertyValue((ushort)value);
+ if (type == typeof(int)) return value => new PropertyValue((int)value);
+ if (type == typeof(uint)) return value => new PropertyValue((uint)value);
+ if (type == typeof(long)) return value => new PropertyValue((long)value);
+ if (type == typeof(ulong)) return value => new PropertyValue((ulong)value);
if (type == typeof(IntPtr)) return value => new PropertyValue((IntPtr)value);
if (type == typeof(UIntPtr)) return value => new PropertyValue((UIntPtr)value);
- if (type == typeof(Single)) return value => new PropertyValue((Single)value);
- if (type == typeof(Double)) return value => new PropertyValue((Double)value);
+ if (type == typeof(float)) return value => new PropertyValue((float)value);
+ if (type == typeof(double)) return value => new PropertyValue((double)value);
if (type == typeof(Guid)) return value => new PropertyValue((Guid)value);
if (type == typeof(DateTime)) return value => new PropertyValue((DateTime)value);
if (type == typeof(DateTimeOffset)) return value => new PropertyValue((DateTimeOffset)value);
if (type == typeof(TimeSpan)) return value => new PropertyValue((TimeSpan)value);
- if (type == typeof(Decimal)) return value => new PropertyValue((Decimal)value);
+ if (type == typeof(decimal)) return value => new PropertyValue((decimal)value);
return value => new PropertyValue(value);
}
if (type.GetTypeInfo().IsEnum)
type = Enum.GetUnderlyingType(type);
- if (type == typeof(Boolean)) { var f = (Func<TContainer, Boolean>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
- if (type == typeof(Byte)) { var f = (Func<TContainer, Byte>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
- if (type == typeof(SByte)) { var f = (Func<TContainer, SByte>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
- if (type == typeof(Char)) { var f = (Func<TContainer, Char>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
- if (type == typeof(Int16)) { var f = (Func<TContainer, Int16>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
- if (type == typeof(UInt16)) { var f = (Func<TContainer, UInt16>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
- if (type == typeof(Int32)) { var f = (Func<TContainer, Int32>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
- if (type == typeof(UInt32)) { var f = (Func<TContainer, UInt32>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
- if (type == typeof(Int64)) { var f = (Func<TContainer, Int64>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
- if (type == typeof(UInt64)) { var f = (Func<TContainer, UInt64>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
+ if (type == typeof(bool)) { var f = (Func<TContainer, bool>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
+ if (type == typeof(byte)) { var f = (Func<TContainer, byte>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
+ if (type == typeof(sbyte)) { var f = (Func<TContainer, sbyte>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
+ if (type == typeof(char)) { var f = (Func<TContainer, char>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
+ if (type == typeof(short)) { var f = (Func<TContainer, short>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
+ if (type == typeof(ushort)) { var f = (Func<TContainer, ushort>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
+ if (type == typeof(int)) { var f = (Func<TContainer, int>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
+ if (type == typeof(uint)) { var f = (Func<TContainer, uint>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
+ if (type == typeof(long)) { var f = (Func<TContainer, long>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
+ if (type == typeof(ulong)) { var f = (Func<TContainer, ulong>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
if (type == typeof(IntPtr)) { var f = (Func<TContainer, IntPtr>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
if (type == typeof(UIntPtr)) { var f = (Func<TContainer, UIntPtr>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
- if (type == typeof(Single)) { var f = (Func<TContainer, Single>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
- if (type == typeof(Double)) { var f = (Func<TContainer, Double>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
+ if (type == typeof(float)) { var f = (Func<TContainer, float>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
+ if (type == typeof(double)) { var f = (Func<TContainer, double>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
if (type == typeof(Guid)) { var f = (Func<TContainer, Guid>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
if (type == typeof(DateTime)) { var f = (Func<TContainer, DateTime>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
if (type == typeof(DateTimeOffset)) { var f = (Func<TContainer, DateTimeOffset>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
if (type == typeof(TimeSpan)) { var f = (Func<TContainer, TimeSpan>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
- if (type == typeof(Decimal)) { var f = (Func<TContainer, Decimal>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
+ if (type == typeof(decimal)) { var f = (Func<TContainer, decimal>)GetGetMethod(property, type); return container => new PropertyValue(f((TContainer)container.ReferenceValue)); }
return container => new PropertyValue(property.GetValue(container.ReferenceValue));
}
collector.AddScalar(value);
}
- public static TraceLoggingTypeInfo Boolean() { return new ScalarTypeInfo(typeof(Boolean), Statics.Format8, TraceLoggingDataType.Boolean8); }
- public static TraceLoggingTypeInfo Byte() { return new ScalarTypeInfo(typeof(Byte), Statics.Format8, TraceLoggingDataType.UInt8); }
- public static TraceLoggingTypeInfo SByte() { return new ScalarTypeInfo(typeof(SByte), Statics.Format8, TraceLoggingDataType.Int8); }
- public static TraceLoggingTypeInfo Char() { return new ScalarTypeInfo(typeof(Char), Statics.Format16, TraceLoggingDataType.Char16); }
- public static TraceLoggingTypeInfo Int16() { return new ScalarTypeInfo(typeof(Int16), Statics.Format16, TraceLoggingDataType.Int16); }
- public static TraceLoggingTypeInfo UInt16() { return new ScalarTypeInfo(typeof(UInt16), Statics.Format16, TraceLoggingDataType.UInt16); }
- public static TraceLoggingTypeInfo Int32() { return new ScalarTypeInfo(typeof(Int32), Statics.Format32, TraceLoggingDataType.Int32); }
- public static TraceLoggingTypeInfo UInt32() { return new ScalarTypeInfo(typeof(UInt32), Statics.Format32, TraceLoggingDataType.UInt32); }
- public static TraceLoggingTypeInfo Int64() { return new ScalarTypeInfo(typeof(Int64), Statics.Format64, TraceLoggingDataType.Int64); }
- public static TraceLoggingTypeInfo UInt64() { return new ScalarTypeInfo(typeof(UInt64), Statics.Format64, TraceLoggingDataType.UInt64); }
+ public static TraceLoggingTypeInfo Boolean() { return new ScalarTypeInfo(typeof(bool), Statics.Format8, TraceLoggingDataType.Boolean8); }
+ public static TraceLoggingTypeInfo Byte() { return new ScalarTypeInfo(typeof(byte), Statics.Format8, TraceLoggingDataType.UInt8); }
+ public static TraceLoggingTypeInfo SByte() { return new ScalarTypeInfo(typeof(sbyte), Statics.Format8, TraceLoggingDataType.Int8); }
+ public static TraceLoggingTypeInfo Char() { return new ScalarTypeInfo(typeof(char), Statics.Format16, TraceLoggingDataType.Char16); }
+ public static TraceLoggingTypeInfo Int16() { return new ScalarTypeInfo(typeof(short), Statics.Format16, TraceLoggingDataType.Int16); }
+ public static TraceLoggingTypeInfo UInt16() { return new ScalarTypeInfo(typeof(ushort), Statics.Format16, TraceLoggingDataType.UInt16); }
+ public static TraceLoggingTypeInfo Int32() { return new ScalarTypeInfo(typeof(int), Statics.Format32, TraceLoggingDataType.Int32); }
+ public static TraceLoggingTypeInfo UInt32() { return new ScalarTypeInfo(typeof(uint), Statics.Format32, TraceLoggingDataType.UInt32); }
+ public static TraceLoggingTypeInfo Int64() { return new ScalarTypeInfo(typeof(long), Statics.Format64, TraceLoggingDataType.Int64); }
+ public static TraceLoggingTypeInfo UInt64() { return new ScalarTypeInfo(typeof(ulong), Statics.Format64, TraceLoggingDataType.UInt64); }
public static TraceLoggingTypeInfo IntPtr() { return new ScalarTypeInfo(typeof(IntPtr), Statics.FormatPtr, Statics.IntPtrType); }
public static TraceLoggingTypeInfo UIntPtr() { return new ScalarTypeInfo(typeof(UIntPtr), Statics.FormatPtr, Statics.UIntPtrType); }
- public static TraceLoggingTypeInfo Single() { return new ScalarTypeInfo(typeof(Single), Statics.Format32, TraceLoggingDataType.Float); }
- public static TraceLoggingTypeInfo Double() { return new ScalarTypeInfo(typeof(Double), Statics.Format64, TraceLoggingDataType.Double); }
+ public static TraceLoggingTypeInfo Single() { return new ScalarTypeInfo(typeof(float), Statics.Format32, TraceLoggingDataType.Float); }
+ public static TraceLoggingTypeInfo Double() { return new ScalarTypeInfo(typeof(double), Statics.Format64, TraceLoggingDataType.Double); }
public static TraceLoggingTypeInfo Guid() { return new ScalarTypeInfo(typeof(Guid), (f, t) => Statics.MakeDataType(TraceLoggingDataType.Guid, f), TraceLoggingDataType.Guid); }
}
collector.AddArray(value, elementSize);
}
- public static TraceLoggingTypeInfo Boolean() { return new ScalarArrayTypeInfo(typeof(Boolean[]), Statics.Format8, TraceLoggingDataType.Boolean8, sizeof(Boolean)); }
- public static TraceLoggingTypeInfo Byte() { return new ScalarArrayTypeInfo(typeof(Byte[]), Statics.Format8, TraceLoggingDataType.UInt8, sizeof(Byte)); }
- public static TraceLoggingTypeInfo SByte() { return new ScalarArrayTypeInfo(typeof(SByte[]), Statics.Format8, TraceLoggingDataType.Int8, sizeof(SByte)); }
- public static TraceLoggingTypeInfo Char() { return new ScalarArrayTypeInfo(typeof(Char[]), Statics.Format16, TraceLoggingDataType.Char16, sizeof(Char)); }
- public static TraceLoggingTypeInfo Int16() { return new ScalarArrayTypeInfo(typeof(Int16[]), Statics.Format16, TraceLoggingDataType.Int16, sizeof(Int16)); }
- public static TraceLoggingTypeInfo UInt16() { return new ScalarArrayTypeInfo(typeof(UInt16[]), Statics.Format16, TraceLoggingDataType.UInt16, sizeof(UInt16)); }
- public static TraceLoggingTypeInfo Int32() { return new ScalarArrayTypeInfo(typeof(Int32[]), Statics.Format32, TraceLoggingDataType.Int32, sizeof(Int32)); }
- public static TraceLoggingTypeInfo UInt32() { return new ScalarArrayTypeInfo(typeof(UInt32[]), Statics.Format32, TraceLoggingDataType.UInt32, sizeof(UInt32)); }
- public static TraceLoggingTypeInfo Int64() { return new ScalarArrayTypeInfo(typeof(Int64[]), Statics.Format64, TraceLoggingDataType.Int64, sizeof(Int64)); }
- public static TraceLoggingTypeInfo UInt64() { return new ScalarArrayTypeInfo(typeof(UInt64[]), Statics.Format64, TraceLoggingDataType.UInt64, sizeof(UInt64)); }
+ public static TraceLoggingTypeInfo Boolean() { return new ScalarArrayTypeInfo(typeof(bool[]), Statics.Format8, TraceLoggingDataType.Boolean8, sizeof(bool)); }
+ public static TraceLoggingTypeInfo Byte() { return new ScalarArrayTypeInfo(typeof(byte[]), Statics.Format8, TraceLoggingDataType.UInt8, sizeof(byte)); }
+ public static TraceLoggingTypeInfo SByte() { return new ScalarArrayTypeInfo(typeof(sbyte[]), Statics.Format8, TraceLoggingDataType.Int8, sizeof(sbyte)); }
+ public static TraceLoggingTypeInfo Char() { return new ScalarArrayTypeInfo(typeof(char[]), Statics.Format16, TraceLoggingDataType.Char16, sizeof(char)); }
+ public static TraceLoggingTypeInfo Int16() { return new ScalarArrayTypeInfo(typeof(short[]), Statics.Format16, TraceLoggingDataType.Int16, sizeof(short)); }
+ public static TraceLoggingTypeInfo UInt16() { return new ScalarArrayTypeInfo(typeof(ushort[]), Statics.Format16, TraceLoggingDataType.UInt16, sizeof(ushort)); }
+ public static TraceLoggingTypeInfo Int32() { return new ScalarArrayTypeInfo(typeof(int[]), Statics.Format32, TraceLoggingDataType.Int32, sizeof(int)); }
+ public static TraceLoggingTypeInfo UInt32() { return new ScalarArrayTypeInfo(typeof(uint[]), Statics.Format32, TraceLoggingDataType.UInt32, sizeof(uint)); }
+ public static TraceLoggingTypeInfo Int64() { return new ScalarArrayTypeInfo(typeof(long[]), Statics.Format64, TraceLoggingDataType.Int64, sizeof(long)); }
+ public static TraceLoggingTypeInfo UInt64() { return new ScalarArrayTypeInfo(typeof(ulong[]), Statics.Format64, TraceLoggingDataType.UInt64, sizeof(ulong)); }
public static TraceLoggingTypeInfo IntPtr() { return new ScalarArrayTypeInfo(typeof(IntPtr[]), Statics.FormatPtr, Statics.IntPtrType, System.IntPtr.Size); }
public static TraceLoggingTypeInfo UIntPtr() { return new ScalarArrayTypeInfo(typeof(UIntPtr[]), Statics.FormatPtr, Statics.UIntPtrType, System.IntPtr.Size); }
- public static TraceLoggingTypeInfo Single() { return new ScalarArrayTypeInfo(typeof(Single[]), Statics.Format32, TraceLoggingDataType.Float, sizeof(Single)); }
- public static TraceLoggingTypeInfo Double() { return new ScalarArrayTypeInfo(typeof(Double[]), Statics.Format64, TraceLoggingDataType.Double, sizeof(Double)); }
+ public static TraceLoggingTypeInfo Single() { return new ScalarArrayTypeInfo(typeof(float[]), Statics.Format32, TraceLoggingDataType.Float, sizeof(float)); }
+ public static TraceLoggingTypeInfo Double() { return new ScalarArrayTypeInfo(typeof(double[]), Statics.Format64, TraceLoggingDataType.Double, sizeof(double)); }
public static unsafe TraceLoggingTypeInfo Guid() { return new ScalarArrayTypeInfo(typeof(Guid), (f, t) => Statics.MakeDataType(TraceLoggingDataType.Guid, f), TraceLoggingDataType.Guid, sizeof(Guid)); }
}
}
/// <summary>
- /// TraceLogging: Type handler for Decimal. (Note: not full-fidelity, exposed as Double.)
+ /// TraceLogging: Type handler for decimal. (Note: not full-fidelity, exposed as Double.)
/// </summary>
internal sealed class DecimalTypeInfo : TraceLoggingTypeInfo
{
- public DecimalTypeInfo() : base(typeof(Decimal)) { }
+ public DecimalTypeInfo() : base(typeof(decimal)) { }
public override void WriteMetadata(
TraceLoggingMetadataCollector collector,
else if (dataType.IsArray)
{
var elementType = dataType.GetElementType();
- if (elementType == typeof(Boolean))
+ if (elementType == typeof(bool))
{
result = ScalarArrayTypeInfo.Boolean();
}
- else if (elementType == typeof(Byte))
+ else if (elementType == typeof(byte))
{
result = ScalarArrayTypeInfo.Byte();
}
- else if (elementType == typeof(SByte))
+ else if (elementType == typeof(sbyte))
{
result = ScalarArrayTypeInfo.SByte();
}
- else if (elementType == typeof(Int16))
+ else if (elementType == typeof(short))
{
result = ScalarArrayTypeInfo.Int16();
}
- else if (elementType == typeof(UInt16))
+ else if (elementType == typeof(ushort))
{
result = ScalarArrayTypeInfo.UInt16();
}
- else if (elementType == typeof(Int32))
+ else if (elementType == typeof(int))
{
result = ScalarArrayTypeInfo.Int32();
}
- else if (elementType == typeof(UInt32))
+ else if (elementType == typeof(uint))
{
result = ScalarArrayTypeInfo.UInt32();
}
- else if (elementType == typeof(Int64))
+ else if (elementType == typeof(long))
{
result = ScalarArrayTypeInfo.Int64();
}
- else if (elementType == typeof(UInt64))
+ else if (elementType == typeof(ulong))
{
result = ScalarArrayTypeInfo.UInt64();
}
- else if (elementType == typeof(Char))
+ else if (elementType == typeof(char))
{
result = ScalarArrayTypeInfo.Char();
}
- else if (elementType == typeof(Double))
+ else if (elementType == typeof(double))
{
result = ScalarArrayTypeInfo.Double();
}
- else if (elementType == typeof(Single))
+ else if (elementType == typeof(float))
{
result = ScalarArrayTypeInfo.Single();
}
if (Statics.IsEnum(dataType))
dataType = Enum.GetUnderlyingType(dataType);
- if (dataType == typeof(String))
+ if (dataType == typeof(string))
{
result = new StringTypeInfo();
}
- else if (dataType == typeof(Boolean))
+ else if (dataType == typeof(bool))
{
result = ScalarTypeInfo.Boolean();
}
- else if (dataType == typeof(Byte))
+ else if (dataType == typeof(byte))
{
result = ScalarTypeInfo.Byte();
}
- else if (dataType == typeof(SByte))
+ else if (dataType == typeof(sbyte))
{
result = ScalarTypeInfo.SByte();
}
- else if (dataType == typeof(Int16))
+ else if (dataType == typeof(short))
{
result = ScalarTypeInfo.Int16();
}
- else if (dataType == typeof(UInt16))
+ else if (dataType == typeof(ushort))
{
result = ScalarTypeInfo.UInt16();
}
- else if (dataType == typeof(Int32))
+ else if (dataType == typeof(int))
{
result = ScalarTypeInfo.Int32();
}
- else if (dataType == typeof(UInt32))
+ else if (dataType == typeof(uint))
{
result = ScalarTypeInfo.UInt32();
}
- else if (dataType == typeof(Int64))
+ else if (dataType == typeof(long))
{
result = ScalarTypeInfo.Int64();
}
- else if (dataType == typeof(UInt64))
+ else if (dataType == typeof(ulong))
{
result = ScalarTypeInfo.UInt64();
}
- else if (dataType == typeof(Char))
+ else if (dataType == typeof(char))
{
result = ScalarTypeInfo.Char();
}
- else if (dataType == typeof(Double))
+ else if (dataType == typeof(double))
{
result = ScalarTypeInfo.Double();
}
- else if (dataType == typeof(Single))
+ else if (dataType == typeof(float))
{
result = ScalarTypeInfo.Single();
}
{
result = new DateTimeTypeInfo();
}
- else if (dataType == typeof(Decimal))
+ else if (dataType == typeof(decimal))
{
result = new DecimalTypeInfo();
}
HResult = HResults.COR_E_DIVIDEBYZERO;
}
- public DivideByZeroException(String message)
+ public DivideByZeroException(string message)
: base(message)
{
HResult = HResults.COR_E_DIVIDEBYZERO;
}
- public DivideByZeroException(String message, Exception innerException)
+ public DivideByZeroException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_DIVIDEBYZERO;
HResult = HResults.COR_E_DLLNOTFOUND;
}
- public DllNotFoundException(String message)
+ public DllNotFoundException(string message)
: base(message)
{
HResult = HResults.COR_E_DLLNOTFOUND;
}
- public DllNotFoundException(String message, Exception inner)
+ public DllNotFoundException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_DLLNOTFOUND;
[Serializable]
[StructLayout(LayoutKind.Sequential)]
[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public struct Double : IComparable, IConvertible, IFormattable, IComparable<Double>, IEquatable<Double>, ISpanFormattable
+ public struct Double : IComparable, IConvertible, IFormattable, IComparable<double>, IEquatable<double>, ISpanFormattable
{
private double m_value; // Do not rename (binary serialization)
//
// Returns a value less than zero if this object
//
- public int CompareTo(Object value)
+ public int CompareTo(object value)
{
if (value == null)
{
return 1;
}
- if (value is Double)
+ if (value is double)
{
double d = (double)value;
if (m_value < d) return -1;
throw new ArgumentException(SR.Arg_MustBeDouble);
}
- public int CompareTo(Double value)
+ public int CompareTo(double value)
{
if (m_value < value) return -1;
if (m_value > value) return 1;
// True if obj is another Double with the same value as the current instance. This is
// a method of object equality, that only returns true if obj is also a double.
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
- if (!(obj is Double))
+ if (!(obj is double))
{
return false;
}
- double temp = ((Double)obj).m_value;
+ double temp = ((double)obj).m_value;
// This code below is written this way for performance reasons i.e the != and == check is intentional.
if (temp == m_value)
{
}
[NonVersionable]
- public static bool operator ==(Double left, Double right)
+ public static bool operator ==(double left, double right)
{
return left == right;
}
[NonVersionable]
- public static bool operator !=(Double left, Double right)
+ public static bool operator !=(double left, double right)
{
return left != right;
}
[NonVersionable]
- public static bool operator <(Double left, Double right)
+ public static bool operator <(double left, double right)
{
return left < right;
}
[NonVersionable]
- public static bool operator >(Double left, Double right)
+ public static bool operator >(double left, double right)
{
return left > right;
}
[NonVersionable]
- public static bool operator <=(Double left, Double right)
+ public static bool operator <=(double left, double right)
{
return left <= right;
}
[NonVersionable]
- public static bool operator >=(Double left, Double right)
+ public static bool operator >=(double left, double right)
{
return left >= right;
}
- public bool Equals(Double obj)
+ public bool Equals(double obj)
{
if (obj == m_value)
{
return unchecked((int)bits) ^ ((int)(bits >> 32));
}
- public override String ToString()
+ public override string ToString()
{
return Number.FormatDouble(m_value, null, NumberFormatInfo.CurrentInfo);
}
- public String ToString(String format)
+ public string ToString(string format)
{
return Number.FormatDouble(m_value, format, NumberFormatInfo.CurrentInfo);
}
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
return Number.FormatDouble(m_value, null, NumberFormatInfo.GetInstance(provider));
}
- public String ToString(String format, IFormatProvider provider)
+ public string ToString(string format, IFormatProvider provider)
{
return Number.FormatDouble(m_value, format, NumberFormatInfo.GetInstance(provider));
}
return Number.TryFormatDouble(m_value, format, NumberFormatInfo.GetInstance(provider), destination, out charsWritten);
}
- public static double Parse(String s)
+ public static double Parse(string s)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseDouble(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo);
}
- public static double Parse(String s, NumberStyles style)
+ public static double Parse(string s, NumberStyles style)
{
NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseDouble(s, style, NumberFormatInfo.CurrentInfo);
}
- public static double Parse(String s, IFormatProvider provider)
+ public static double Parse(string s, IFormatProvider provider)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseDouble(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.GetInstance(provider));
}
- public static double Parse(String s, NumberStyles style, IFormatProvider provider)
+ public static double Parse(string s, NumberStyles style, IFormatProvider provider)
{
NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
- public static bool TryParse(String s, out double result)
+ public static bool TryParse(string s, out double result)
{
if (s == null)
{
return TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo, out result);
}
- public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out double result)
+ public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out double result)
{
NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
return m_value;
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
return Convert.ToDecimal(m_value);
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Double", "DateTime"));
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
[System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
public class DuplicateWaitObjectException : ArgumentException
{
- private static volatile String s_duplicateWaitObjectMessage = null;
+ private static volatile string s_duplicateWaitObjectMessage = null;
- private static String DuplicateWaitObjectMessage
+ private static string DuplicateWaitObjectMessage
{
get
{
HResult = HResults.COR_E_DUPLICATEWAITOBJECT;
}
- public DuplicateWaitObjectException(String parameterName)
+ public DuplicateWaitObjectException(string parameterName)
: base(DuplicateWaitObjectMessage, parameterName)
{
HResult = HResults.COR_E_DUPLICATEWAITOBJECT;
}
- public DuplicateWaitObjectException(String parameterName, String message)
+ public DuplicateWaitObjectException(string parameterName, string message)
: base(message, parameterName)
{
HResult = HResults.COR_E_DUPLICATEWAITOBJECT;
}
- public DuplicateWaitObjectException(String message, Exception innerException)
+ public DuplicateWaitObjectException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_DUPLICATEWAITOBJECT;
HResult = HResults.COR_E_ENTRYPOINTNOTFOUND;
}
- public EntryPointNotFoundException(String message)
+ public EntryPointNotFoundException(string message)
: base(message)
{
HResult = HResults.COR_E_ENTRYPOINTNOTFOUND;
}
- public EntryPointNotFoundException(String message, Exception inner)
+ public EntryPointNotFoundException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_ENTRYPOINTNOTFOUND;
namespace System
{
- public delegate void EventHandler(Object sender, EventArgs e);
+ public delegate void EventHandler(object sender, EventArgs e);
- public delegate void EventHandler<TEventArgs>(Object sender, TEventArgs e); // Removed TEventArgs constraint post-.NET 4
+ public delegate void EventHandler<TEventArgs>(object sender, TEventArgs e); // Removed TEventArgs constraint post-.NET 4
}
HResult = HResults.COR_E_EXECUTIONENGINE;
}
- public ExecutionEngineException(String message)
+ public ExecutionEngineException(string message)
: base(message)
{
HResult = HResults.COR_E_EXECUTIONENGINE;
}
- public ExecutionEngineException(String message, Exception innerException)
+ public ExecutionEngineException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_EXECUTIONENGINE;
HResult = HResults.COR_E_FIELDACCESS;
}
- public FieldAccessException(String message)
+ public FieldAccessException(string message)
: base(message)
{
HResult = HResults.COR_E_FIELDACCESS;
}
- public FieldAccessException(String message, Exception inner)
+ public FieldAccessException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_FIELDACCESS;
HResult = HResults.COR_E_FORMAT;
}
- public FormatException(String message)
+ public FormatException(string message)
: base(message)
{
HResult = HResults.COR_E_FORMAT;
}
- public FormatException(String message, Exception innerException)
+ public FormatException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_FORMAT;
public abstract DateTime ToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era);
- internal virtual Boolean TryToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era, out DateTime result)
+ internal virtual bool TryToDateTime(int year, int month, int day, int hour, int minute, int second, int millisecond, int era, out DateTime result)
{
result = DateTime.MinValue;
try
{
internal partial class CalendarData
{
- private bool LoadCalendarDataFromSystem(String localeName, CalendarId calendarId)
+ private bool LoadCalendarDataFromSystem(string localeName, CalendarId calendarId)
{
Debug.Assert(!GlobalizationMode.Invariant);
}
// Call native side to figure out which calendars are allowed
- internal static int GetCalendars(String localeName, bool useUserOverride, CalendarId[] calendars)
+ internal static int GetCalendars(string localeName, bool useUserOverride, CalendarId[] calendars)
{
Debug.Assert(!GlobalizationMode.Invariant);
}
}
- private static unsafe String GetUserDefaultLocaleName()
+ private static unsafe string GetUserDefaultLocaleName()
{
Debug.Assert(!GlobalizationMode.Invariant);
char* localeName = stackalloc char[LOCALE_NAME_MAX_LENGTH];
result = CultureData.GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT, LOCALE_SNAME, localeName, LOCALE_NAME_MAX_LENGTH);
- return result <= 0 ? "" : new String(localeName, 0, result - 1); // exclude the null termination
+ return result <= 0 ? "" : new string(localeName, 0, result - 1); // exclude the null termination
}
}
}
//
// Actions:
// Convert the BMP character or surrogate pointed by index to a UTF32 value.
- // This is similar to Char.ConvertToUTF32, but the difference is that
+ // This is similar to char.ConvertToUTF32, but the difference is that
// it does not throw exceptions when invalid surrogate characters are passed in.
//
// WARNING: since it doesn't throw an exception it CAN return a value
//
////////////////////////////////////////////////////////////////////////
- internal static int InternalConvertToUtf32(String s, int index)
+ internal static int InternalConvertToUtf32(string s, int index)
{
Debug.Assert(s != null, "s != null");
Debug.Assert(index >= 0 && index < s.Length, "index < s.Length");
//
////////////////////////////////////////////////////////////////////////
- internal static int InternalConvertToUtf32(String s, int index, out int charLength)
+ internal static int InternalConvertToUtf32(string s, int index, out int charLength)
{
Debug.Assert(s != null, "s != null");
Debug.Assert(s.Length > 0, "s.Length > 0");
//
////////////////////////////////////////////////////////////////////////
- internal static bool IsWhiteSpace(String s, int index)
+ internal static bool IsWhiteSpace(string s, int index)
{
Debug.Assert(s != null, "s!=null");
Debug.Assert(index >= 0 && index < s.Length, "index >= 0 && index < s.Length");
}
- public static double GetNumericValue(String s, int index)
+ public static double GetNumericValue(string s, int index)
{
if (s == null)
{
return (sbyte)(InternalGetDigitValues(ch) >> 8);
}
- public static int GetDecimalDigitValue(String s, int index)
+ public static int GetDecimalDigitValue(string s, int index)
{
if (s == null)
{
return (sbyte)(InternalGetDigitValues(ch) & 0x00FF);
}
- public static int GetDigitValue(String s, int index)
+ public static int GetDigitValue(string s, int index)
{
if (s == null)
{
return (GetUnicodeCategory((int)ch));
}
- public static UnicodeCategory GetUnicodeCategory(String s, int index)
+ public static UnicodeCategory GetUnicodeCategory(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
//
////////////////////////////////////////////////////////////////////////
- internal static UnicodeCategory InternalGetUnicodeCategory(String value, int index)
+ internal static UnicodeCategory InternalGetUnicodeCategory(string value, int index)
{
Debug.Assert(value != null, "value can not be null");
Debug.Assert(index < value.Length, "index < value.Length");
return (GetUnicodeCategory(InternalConvertToUtf32(value, index)));
}
- internal static BidiCategory GetBidiCategory(String s, int index)
+ internal static BidiCategory GetBidiCategory(string s, int index)
{
if (s == null)
throw new ArgumentNullException(nameof(s));
//
////////////////////////////////////////////////////////////////////////
- internal static UnicodeCategory InternalGetUnicodeCategory(String str, int index, out int charLength)
+ internal static UnicodeCategory InternalGetUnicodeCategory(string str, int index, out int charLength)
{
Debug.Assert(str != null, "str can not be null");
Debug.Assert(str.Length > 0, "str.Length > 0"); ;
while (index < length)
{
- if (Char.IsHighSurrogate(text[index]))
+ if (char.IsHighSurrogate(text[index]))
{
- if (index == length - 1 || !Char.IsLowSurrogate(text[index+1]))
+ if (index == length - 1 || !char.IsLowSurrogate(text[index+1]))
return false; // unpaired surrogate
- uc = CharUnicodeInfo.GetUnicodeCategory(Char.ConvertToUtf32(text[index], text[index+1]));
+ uc = CharUnicodeInfo.GetUnicodeCategory(char.ConvertToUtf32(text[index], text[index+1]));
if (uc == UnicodeCategory.PrivateUse || uc == UnicodeCategory.OtherNotAssigned)
return false;
continue;
}
- if (Char.IsLowSurrogate(text[index]))
+ if (char.IsLowSurrogate(text[index]))
{
return false; // unpaired surrogate
}
}
}
- internal unsafe int IndexOfCore(String source, String target, int startIndex, int count, CompareOptions options, int* matchLengthPtr)
+ internal unsafe int IndexOfCore(string source, string target, int startIndex, int count, CompareOptions options, int* matchLengthPtr)
{
Debug.Assert(!_invariantMode);
return retValue;
}
- private unsafe SortKey CreateSortKey(String source, CompareOptions options)
+ private unsafe SortKey CreateSortKey(string source, CompareOptions options)
{
Debug.Assert(!_invariantMode);
{
throw new ArgumentNullException(nameof(assembly));
}
- if (assembly != typeof(Object).Module.Assembly)
+ if (assembly != typeof(object).Module.Assembly)
{
throw new ArgumentException(SR.Argument_OnlyMscorlib);
}
throw new ArgumentNullException(name == null ? nameof(name) : nameof(assembly));
}
- if (assembly != typeof(Object).Module.Assembly)
+ if (assembly != typeof(object).Module.Assembly)
{
throw new ArgumentException(SR.Argument_OnlyMscorlib);
}
// IsPrefix
//
// Determines whether prefix is a prefix of string. If prefix equals
- // String.Empty, true is returned.
+ // string.Empty, true is returned.
//
////////////////////////////////////////////////////////////////////////
public virtual bool IsPrefix(string source, string prefix, CompareOptions options)
// IsSuffix
//
// Determines whether suffix is a suffix of string. If suffix equals
- // String.Empty, true is returned.
+ // string.Empty, true is returned.
//
////////////////////////////////////////////////////////////////////////
public virtual bool IsSuffix(string source, string suffix, CompareOptions options)
//
// Returns the first index where value is found in string. The
// search starts from startIndex and ends at endIndex. Returns -1 if
- // the specified value is not found. If value equals String.Empty,
+ // the specified value is not found. If value equals string.Empty,
// startIndex is returned. Throws IndexOutOfRange if startIndex or
// endIndex is less than zero or greater than the length of string.
// Throws ArgumentException if value is null.
//
// Returns the last index where value is found in string. The
// search starts from startIndex and ends at endIndex. Returns -1 if
- // the specified value is not found. If value equals String.Empty,
+ // the specified value is not found. If value equals string.Empty,
// endIndex is returned. Throws IndexOutOfRange if startIndex or
// endIndex is less than zero or greater than the length of string.
// Throws ArgumentException if value is null.
////////////////////////////////////////////////////////////////////////
- public virtual int LastIndexOf(String source, char value)
+ public virtual int LastIndexOf(string source, char value)
{
if (source == null)
throw new ArgumentNullException(nameof(source));
////////////////////////////////////////////////////////////////////////
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
CompareInfo that = value as CompareInfo;
// Failed, just use empty string
StringBuilderCache.Release(sb);
Debug.Fail("[CultureData.GetLocaleInfo(LocaleStringData)] Failed");
- return String.Empty;
+ return string.Empty;
}
return StringBuilderCache.GetStringAndRelease(sb);
}
// Failed, just use empty string
StringBuilderCache.Release(sb);
Debug.Fail("[CultureData.GetTimeFormatString(bool shortFormat)] Failed");
- return String.Empty;
+ return string.Empty;
}
return ConvertIcuTimeFormatString(StringBuilderCache.GetStringAndRelease(sb));
// If the digits of the value is greater than len, no leading zero is added.
//
// Notes:
- // The function can format to Int32.MaxValue.
+ // The function can format to int.MaxValue.
//
////////////////////////////////////////////////////////////////////////////
internal static void FormatDigits(StringBuilder outputBuffer, int value, int len)
// output the 'z' famliy of formats, which output a the offset from UTC, e.g. "-07:30"
- private static void FormatCustomizedTimeZone(DateTime dateTime, TimeSpan offset, ReadOnlySpan<char> format, Int32 tokenLen, Boolean timeOnly, StringBuilder result)
+ private static void FormatCustomizedTimeZone(DateTime dateTime, TimeSpan offset, ReadOnlySpan<char> format, int tokenLen, bool timeOnly, StringBuilder result)
{
// See if the instance already has an offset
- Boolean dateTimeFormat = (offset == NullOffset);
+ bool dateTimeFormat = (offset == NullOffset);
if (dateTimeFormat)
{
// No offset. The instance is a DateTime and the output should be the local time zone
Debug.Assert(dtfi != null);
if (format.Length == 0)
{
- Boolean timeOnlySpecialCase = false;
+ bool timeOnlySpecialCase = false;
if (dateTime.Ticks < Calendar.TicksPerDay)
{
// If the time is less than 1 day, consider it as time of day.
private CultureData _cultureData;
// The culture name used to create this DTFI.
- private String _name = null;
+ private string _name = null;
// The language name of the culture used to create this DTFI.
- private String _langName = null;
+ private string _langName = null;
// CompareInfo usually used by the parser.
private CompareInfo _compareInfo = null;
// Caches for various properties.
//
- private String amDesignator = null;
- private String pmDesignator = null;
+ private string amDesignator = null;
+ private string pmDesignator = null;
- private String dateSeparator = null; // derived from short date (whidbey expects, arrowhead doesn't)
+ private string dateSeparator = null; // derived from short date (whidbey expects, arrowhead doesn't)
- private String generalShortTimePattern = null; // short date + short time (whidbey expects, arrowhead doesn't)
+ private string generalShortTimePattern = null; // short date + short time (whidbey expects, arrowhead doesn't)
- private String generalLongTimePattern = null; // short date + long time (whidbey expects, arrowhead doesn't)
+ private string generalLongTimePattern = null; // short date + long time (whidbey expects, arrowhead doesn't)
- private String timeSeparator = null; // derived from long time (whidbey expects, arrowhead doesn't)
- private String monthDayPattern = null;
+ private string timeSeparator = null; // derived from long time (whidbey expects, arrowhead doesn't)
+ private string monthDayPattern = null;
// added in .NET Framework Release {2.0SP1/3.0SP1/3.5RTM}
- private String dateTimeOffsetPattern = null;
+ private string dateTimeOffsetPattern = null;
//
// The following are constant values.
//
- private const String rfc1123Pattern = "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'";
+ private const string rfc1123Pattern = "ddd, dd MMM yyyy HH':'mm':'ss 'GMT'";
// The sortable pattern is based on ISO 8601.
- private const String sortableDateTimePattern = "yyyy'-'MM'-'dd'T'HH':'mm':'ss";
- private const String universalSortableDateTimePattern = "yyyy'-'MM'-'dd HH':'mm':'ss'Z'";
+ private const string sortableDateTimePattern = "yyyy'-'MM'-'dd'T'HH':'mm':'ss";
+ private const string universalSortableDateTimePattern = "yyyy'-'MM'-'dd HH':'mm':'ss'Z'";
//
// The following are affected by calendar settings.
private int calendarWeekRule = -1;
- private String fullDateTimePattern = null; // long date + long time (whidbey expects, arrowhead doesn't)
+ private string fullDateTimePattern = null; // long date + long time (whidbey expects, arrowhead doesn't)
- private String[] abbreviatedDayNames = null;
+ private string[] abbreviatedDayNames = null;
- private String[] m_superShortDayNames = null;
+ private string[] m_superShortDayNames = null;
- private String[] dayNames = null;
- private String[] abbreviatedMonthNames = null;
- private String[] monthNames = null;
+ private string[] dayNames = null;
+ private string[] abbreviatedMonthNames = null;
+ private string[] monthNames = null;
// Cache the genitive month names that we retrieve from the data table.
- private String[] genitiveMonthNames = null;
+ private string[] genitiveMonthNames = null;
// Cache the abbreviated genitive month names that we retrieve from the data table.
- private String[] m_genitiveAbbreviatedMonthNames = null;
+ private string[] m_genitiveAbbreviatedMonthNames = null;
// Cache the month names of a leap year that we retrieve from the data table.
- private String[] leapYearMonthNames = null;
+ private string[] leapYearMonthNames = null;
// For our "patterns" arrays we have 2 variables, a string and a string[]
//
// When we initially construct our string[], we set the string to string[0]
// The "default" Date/time patterns
- private String longDatePattern = null;
- private String shortDatePattern = null;
- private String yearMonthPattern = null;
- private String longTimePattern = null;
- private String shortTimePattern = null;
+ private string longDatePattern = null;
+ private string shortDatePattern = null;
+ private string yearMonthPattern = null;
+ private string longTimePattern = null;
+ private string shortTimePattern = null;
- private String[] allYearMonthPatterns = null;
+ private string[] allYearMonthPatterns = null;
- private String[] allShortDatePatterns = null;
- private String[] allLongDatePatterns = null;
- private String[] allShortTimePatterns = null;
- private String[] allLongTimePatterns = null;
+ private string[] allShortDatePatterns = null;
+ private string[] allLongDatePatterns = null;
+ private string[] allShortTimePatterns = null;
+ private string[] allLongTimePatterns = null;
// Cache the era names for this DateTimeFormatInfo instance.
- private String[] m_eraNames = null;
- private String[] m_abbrevEraNames = null;
- private String[] m_abbrevEnglishEraNames = null;
+ private string[] m_eraNames = null;
+ private string[] m_abbrevEraNames = null;
+ private string[] m_abbrevEnglishEraNames = null;
private CalendarId[] optionalCalendars = null;
private DateTimeFormatFlags formatFlags = DateTimeFormatFlags.NotInitialized;
- private String CultureName
+ private string CultureName
{
get
{
}
// TODO: This ignores other cultures that might want to do something similar
- private String LanguageName
+ private string LanguageName
{
get
{
//
////////////////////////////////////////////////////////////////////////////
- private String[] internalGetAbbreviatedMonthNames() => this.abbreviatedMonthNames ?? internalGetAbbreviatedMonthNamesCore();
+ private string[] internalGetAbbreviatedMonthNames() => this.abbreviatedMonthNames ?? internalGetAbbreviatedMonthNamesCore();
[MethodImpl(MethodImplOptions.NoInlining)]
- private String[] internalGetAbbreviatedMonthNamesCore()
+ private string[] internalGetAbbreviatedMonthNamesCore()
{
// Get the month names for our current calendar
this.abbreviatedMonthNames = _cultureData.AbbreviatedMonthNames(Calendar.ID);
provider.GetFormat(typeof(DateTimeFormatInfo)) is DateTimeFormatInfo info2 ? info2 :
CurrentInfo; // Couldn't get anything, just use currentInfo as fallback
- public Object GetFormat(Type formatType)
+ public object GetFormat(Type formatType)
{
return (formatType == typeof(DateTimeFormatInfo) ? this : null);
}
- public Object Clone()
+ public object Clone()
{
DateTimeFormatInfo n = (DateTimeFormatInfo)MemberwiseClone();
// We can use the data member calendar in the setter, instead of the property Calendar,
}
- public String AMDesignator
+ public string AMDesignator
{
get
{
============================================================================*/
- public int GetEra(String eraName)
+ public int GetEra(string eraName)
{
if (eraName == null)
{
}
- internal String[] EraNames
+ internal string[] EraNames
{
get
{
============================================================================*/
// Era names are 1 indexed
- public String GetEraName(int era)
+ public string GetEraName(int era)
{
if (era == Calendar.CurrentEra)
{
throw new ArgumentOutOfRangeException(nameof(era), SR.ArgumentOutOfRange_InvalidEraValue);
}
- internal String[] AbbreviatedEraNames
+ internal string[] AbbreviatedEraNames
{
get
{
}
// Era names are 1 indexed
- public String GetAbbreviatedEraName(int era)
+ public string GetAbbreviatedEraName(int era)
{
if (AbbreviatedEraNames.Length == 0)
{
throw new ArgumentOutOfRangeException(nameof(era), SR.ArgumentOutOfRange_InvalidEraValue);
}
- internal String[] AbbreviatedEnglishEraNames
+ internal string[] AbbreviatedEnglishEraNames
{
get
{
}
}
- public String FullDateTimePattern
+ public string FullDateTimePattern
{
get
{
// The string[] contains the list of patterns, EXCEPT the default may not be included.
// The string contains the default pattern.
// When we initially construct our string[], we set the string to string[0]
- public String LongDatePattern
+ public string LongDatePattern
{
get
{
// The string[] contains the list of patterns, EXCEPT the default may not be included.
// The string contains the default pattern.
// When we initially construct our string[], we set the string to string[0]
- public String LongTimePattern
+ public string LongTimePattern
{
get
{
// Note: just to be confusing there's only 1 month day pattern, not a whole list
- public String MonthDayPattern
+ public string MonthDayPattern
{
get
{
}
- public String PMDesignator
+ public string PMDesignator
{
get
{
}
- public String RFC1123Pattern
+ public string RFC1123Pattern
{
get
{
// The string[] contains the list of patterns, EXCEPT the default may not be included.
// The string contains the default pattern.
// When we initially construct our string[], we set the string to string[0]
- public String ShortDatePattern
+ public string ShortDatePattern
{
get
{
// The string[] contains the list of patterns, EXCEPT the default may not be included.
// The string contains the default pattern.
// When we initially construct our string[], we set the string to string[0]
- public String ShortTimePattern
+ public string ShortTimePattern
{
get
{
}
- public String SortableDateTimePattern
+ public string SortableDateTimePattern
{
get
{
** concatation every time somebody asks for the general format.
==============================================================================*/
- internal String GeneralShortTimePattern
+ internal string GeneralShortTimePattern
{
get
{
** concatation every time somebody asks for the general format.
==============================================================================*/
- internal String GeneralLongTimePattern
+ internal string GeneralLongTimePattern
{
get
{
** concatation every time somebody uses this form
==============================================================================*/
- internal String DateTimeOffsetPattern
+ internal string DateTimeOffsetPattern
{
get
{
}
}
- public String UniversalSortableDateTimePattern
+ public string UniversalSortableDateTimePattern
{
get
{
// The string[] contains the list of patterns, EXCEPT the default may not be included.
// The string contains the default pattern.
// When we initially construct our string[], we set the string to string[0]
- public String YearMonthPattern
+ public string YearMonthPattern
{
get
{
//
// Check if a string array contains a null value, and throw ArgumentNullException with parameter name "value"
//
- private static void CheckNullValue(String[] values, int length)
+ private static void CheckNullValue(string[] values, int length)
{
Debug.Assert(values != null, "value != null");
Debug.Assert(values.Length >= length);
}
- public String[] AbbreviatedDayNames
+ public string[] AbbreviatedDayNames
{
get
{
- return ((String[])internalGetAbbreviatedDayOfWeekNames().Clone());
+ return ((string[])internalGetAbbreviatedDayOfWeekNames().Clone());
}
set
}
// Returns the string array of the one-letter day of week names.
- public String[] ShortestDayNames
+ public string[] ShortestDayNames
{
get
{
- return ((String[])internalGetSuperShortDayNames().Clone());
+ return ((string[])internalGetSuperShortDayNames().Clone());
}
set
}
- public String[] DayNames
+ public string[] DayNames
{
get
{
- return ((String[])internalGetDayOfWeekNames().Clone());
+ return ((string[])internalGetDayOfWeekNames().Clone());
}
set
}
- public String[] AbbreviatedMonthNames
+ public string[] AbbreviatedMonthNames
{
get
{
- return ((String[])internalGetAbbreviatedMonthNames().Clone());
+ return ((string[])internalGetAbbreviatedMonthNames().Clone());
}
set
}
- public String[] MonthNames
+ public string[] MonthNames
{
get
{
- return ((String[])internalGetMonthNames().Clone());
+ return ((string[])internalGetMonthNames().Clone());
}
set
// Exceptions:
// ArgumentOutOfRangeException When month name is invalid.
//
- internal String internalGetMonthName(int month, MonthNameStyles style, bool abbreviated)
+ internal string internalGetMonthName(int month, MonthNameStyles style, bool abbreviated)
{
//
// Right now, style is mutual exclusive, but I make the style to be flag so that
// maybe we can combine flag if there is such a need.
//
- String[] monthNamesArray = null;
+ string[] monthNamesArray = null;
switch (style)
{
case MonthNameStyles.Genitive:
// Arguments:
// abbreviated When true, return abbreviated form. Otherwise, return a full form.
//
- private String[] internalGetGenitiveMonthNames(bool abbreviated)
+ private string[] internalGetGenitiveMonthNames(bool abbreviated)
{
if (abbreviated)
{
// If this culture does not have different month names in a leap year, the normal month name is returned.
// Arguments: None. (can use abbreviated later if needed)
//
- internal String[] internalGetLeapYearMonthNames(/*bool abbreviated*/)
+ internal string[] internalGetLeapYearMonthNames(/*bool abbreviated*/)
{
if (this.leapYearMonthNames == null)
{
}
- public String GetAbbreviatedDayName(DayOfWeek dayofweek)
+ public string GetAbbreviatedDayName(DayOfWeek dayofweek)
{
if ((int)dayofweek < 0 || (int)dayofweek > 6)
{
}
// Get all possible combination of inputs
- private static String[] GetCombinedPatterns(String[] patterns1, String[] patterns2, String connectString)
+ private static string[] GetCombinedPatterns(string[] patterns1, string[] patterns2, string connectString)
{
Debug.Assert(patterns1 != null);
Debug.Assert(patterns2 != null);
// Get array size
- String[] result = new String[patterns1.Length * patterns2.Length];
+ string[] result = new string[patterns1.Length * patterns2.Length];
// Counter of actual results
int k = 0;
public string[] GetAllDateTimePatterns()
{
- List<String> results = new List<String>(DEFAULT_ALL_DATETIMES_SIZE);
+ List<string> results = new List<string>(DEFAULT_ALL_DATETIMES_SIZE);
for (int i = 0; i < DateTimeFormat.allStandardFormats.Length; i++)
{
- String[] strings = GetAllDateTimePatterns(DateTimeFormat.allStandardFormats[i]);
+ string[] strings = GetAllDateTimePatterns(DateTimeFormat.allStandardFormats[i]);
for (int j = 0; j < strings.Length; j++)
{
results.Add(strings[j]);
public string[] GetAllDateTimePatterns(char format)
{
- String[] result = null;
+ string[] result = null;
switch (format)
{
break;
case 'm':
case 'M':
- result = new String[] { MonthDayPattern };
+ result = new string[] { MonthDayPattern };
break;
case 'o':
case 'O':
- result = new String[] { RoundtripFormat };
+ result = new string[] { RoundtripFormat };
break;
case 'r':
case 'R':
- result = new String[] { rfc1123Pattern };
+ result = new string[] { rfc1123Pattern };
break;
case 's':
- result = new String[] { sortableDateTimePattern };
+ result = new string[] { sortableDateTimePattern };
break;
case 't':
result = this.AllShortTimePatterns;
result = this.AllLongTimePatterns;
break;
case 'u':
- result = new String[] { UniversalSortableDateTimePattern };
+ result = new string[] { UniversalSortableDateTimePattern };
break;
case 'y':
case 'Y':
}
- public String GetDayName(DayOfWeek dayofweek)
+ public string GetDayName(DayOfWeek dayofweek)
{
if ((int)dayofweek < 0 || (int)dayofweek > 6)
{
return (internalGetDayOfWeekNames()[(int)dayofweek]);
}
- public String GetAbbreviatedMonthName(int month)
+ public string GetAbbreviatedMonthName(int month)
{
if (month < 1 || month > 13)
{
return (internalGetAbbreviatedMonthNames()[month - 1]);
}
- public String GetMonthName(int month)
+ public string GetMonthName(int month)
{
if (month < 1 || month > 13)
{
else
{
// Not found, make room for it
- newPatterns = new String[patterns.Length + 1];
+ newPatterns = new string[patterns.Length + 1];
// Copy existing array
Array.Copy(patterns, 0, newPatterns, 1, patterns.Length);
}
// Needed by DateTimeFormatInfo and DateTimeFormat
- internal const String RoundtripFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.fffffffK";
- internal const String RoundtripDateTimeUnfixed = "yyyy'-'MM'-'ddTHH':'mm':'ss zzz";
+ internal const string RoundtripFormat = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.fffffffK";
+ internal const string RoundtripDateTimeUnfixed = "yyyy'-'MM'-'ddTHH':'mm':'ss zzz";
// Default string isn't necessarily in our string array, so get the
// merged patterns of both
- private String[] AllYearMonthPatterns
+ private string[] AllYearMonthPatterns
{
get
{
}
}
- private String[] AllShortDatePatterns
+ private string[] AllShortDatePatterns
{
get
{
}
}
- private String[] AllShortTimePatterns
+ private string[] AllShortTimePatterns
{
get
{
}
}
- private String[] AllLongDatePatterns
+ private string[] AllLongDatePatterns
{
get
{
}
}
- private String[] AllLongTimePatterns
+ private string[] AllLongTimePatterns
{
get
{
// NOTE: Clone this string array if you want to return it to user. Otherwise, you are returning a writable cache copy.
// This won't include default, call AllYearMonthPatterns
- private String[] UnclonedYearMonthPatterns
+ private string[] UnclonedYearMonthPatterns
{
get
{
// NOTE: Clone this string array if you want to return it to user. Otherwise, you are returning a writable cache copy.
// This won't include default, call AllShortDatePatterns
- private String[] UnclonedShortDatePatterns
+ private string[] UnclonedShortDatePatterns
{
get
{
// NOTE: Clone this string array if you want to return it to user. Otherwise, you are returning a writable cache copy.
// This won't include default, call AllLongDatePatterns
- private String[] UnclonedLongDatePatterns
+ private string[] UnclonedLongDatePatterns
{
get
{
// NOTE: Clone this string array if you want to return it to user. Otherwise, you are returning a writable cache copy.
// This won't include default, call AllShortTimePatterns
- private String[] UnclonedShortTimePatterns
+ private string[] UnclonedShortTimePatterns
{
get
{
// NOTE: Clone this string array if you want to return it to user. Otherwise, you are returning a writable cache copy.
// This won't include default, call AllLongTimePatterns
- private String[] UnclonedLongTimePatterns
+ private string[] UnclonedLongTimePatterns
{
get
{
//
// WARNING: If more validation is ever done in one place, it should be done in the other.
//
- public void SetAllDateTimePatterns(String[] patterns, char format)
+ public void SetAllDateTimePatterns(string[] patterns, char format)
{
if (IsReadOnly)
throw new InvalidOperationException(SR.InvalidOperation_ReadOnly);
ClearTokenHashTable();
}
- public String[] AbbreviatedMonthGenitiveNames
+ public string[] AbbreviatedMonthGenitiveNames
{
get
{
- return ((String[])internalGetGenitiveMonthNames(true).Clone());
+ return ((string[])internalGetGenitiveMonthNames(true).Clone());
}
set
}
}
- public String[] MonthGenitiveNames
+ public string[] MonthGenitiveNames
{
get
{
- return ((String[])internalGetGenitiveMonthNames(false).Clone());
+ return ((string[])internalGetGenitiveMonthNames(false).Clone());
}
set
// Positive TimeSpan Pattern
//
private string _fullTimeSpanPositivePattern;
- internal String FullTimeSpanPositivePattern
+ internal string FullTimeSpanPositivePattern
{
get
{
cultureDataWithoutUserOverrides = CultureData.GetCultureData(_cultureData.CultureName, false);
else
cultureDataWithoutUserOverrides = _cultureData;
- String decimalSeparator = new NumberFormatInfo(cultureDataWithoutUserOverrides).NumberDecimalSeparator;
+ string decimalSeparator = new NumberFormatInfo(cultureDataWithoutUserOverrides).NumberDecimalSeparator;
_fullTimeSpanPositivePattern = "d':'h':'mm':'ss'" + decimalSeparator + "'FFFFFFF";
}
// Negative TimeSpan Pattern
//
private string _fullTimeSpanNegativePattern;
- internal String FullTimeSpanNegativePattern
+ internal string FullTimeSpanNegativePattern
{
get
{
| DateTimeStyles.AdjustToUniversal | DateTimeStyles.AssumeLocal
| DateTimeStyles.AssumeUniversal | DateTimeStyles.RoundtripKind);
- internal static void ValidateStyles(DateTimeStyles style, String parameterName)
+ internal static void ValidateStyles(DateTimeStyles style, string parameterName)
{
if ((style & InvalidDateTimeStyles) != 0)
{
return formatFlags;
}
- internal Boolean HasForceTwoDigitYears
+ internal bool HasForceTwoDigitYears
{
get
{
}
// Returns whether the YearMonthAdjustment function has any fix-up work to do for this culture/calendar.
- internal Boolean HasYearMonthAdjustment
+ internal bool HasYearMonthAdjustment
{
get
{
// the Hebrew calendar, but this could be extended to other cultures.
//
// The return value is whether the year and month are actually valid for this calendar.
- internal Boolean YearMonthAdjustment(ref int year, ref int month, Boolean parsedMonthName)
+ internal bool YearMonthAdjustment(ref int year, ref int month, bool parsedMonthName)
{
if ((FormatFlags & DateTimeFormatFlags.UseHebrewRule) != 0)
{
private const int TOKEN_HASH_SIZE = 199;
private const int SECOND_PRIME = 197;
- private const String dateSeparatorOrTimeZoneOffset = "-";
- private const String invariantDateSeparator = "/";
- private const String invariantTimeSeparator = ":";
+ private const string dateSeparatorOrTimeZoneOffset = "-";
+ private const string invariantDateSeparator = "/";
+ private const string invariantTimeSeparator = ":";
//
// Common Ignorable Symbols
//
- internal const String IgnorablePeriod = ".";
- internal const String IgnorableComma = ",";
+ internal const string IgnorablePeriod = ".";
+ internal const string IgnorableComma = ",";
//
// Year/Month/Day suffixes
//
- internal const String CJKYearSuff = "\u5e74";
- internal const String CJKMonthSuff = "\u6708";
- internal const String CJKDaySuff = "\u65e5";
+ internal const string CJKYearSuff = "\u5e74";
+ internal const string CJKMonthSuff = "\u6708";
+ internal const string CJKDaySuff = "\u65e5";
- internal const String KoreanYearSuff = "\ub144";
- internal const String KoreanMonthSuff = "\uc6d4";
- internal const String KoreanDaySuff = "\uc77c";
+ internal const string KoreanYearSuff = "\ub144";
+ internal const string KoreanMonthSuff = "\uc6d4";
+ internal const string KoreanDaySuff = "\uc77c";
- internal const String KoreanHourSuff = "\uc2dc";
- internal const String KoreanMinuteSuff = "\ubd84";
- internal const String KoreanSecondSuff = "\ucd08";
+ internal const string KoreanHourSuff = "\uc2dc";
+ internal const string KoreanMinuteSuff = "\ubd84";
+ internal const string KoreanSecondSuff = "\ucd08";
- internal const String CJKHourSuff = "\u6642";
- internal const String ChineseHourSuff = "\u65f6";
+ internal const string CJKHourSuff = "\u6642";
+ internal const string ChineseHourSuff = "\u65f6";
- internal const String CJKMinuteSuff = "\u5206";
- internal const String CJKSecondSuff = "\u79d2";
+ internal const string CJKMinuteSuff = "\u5206";
+ internal const string CJKSecondSuff = "\u79d2";
- internal const String LocalTimeMark = "T";
+ internal const string LocalTimeMark = "T";
- internal const String GMTName = "GMT";
- internal const String ZuluName = "Z";
+ internal const string GMTName = "GMT";
+ internal const string ZuluName = "Z";
- internal const String KoreanLangName = "ko";
- internal const String JapaneseLangName = "ja";
- internal const String EnglishLangName = "en";
+ internal const string KoreanLangName = "ko";
+ internal const string JapaneseLangName = "ja";
+ internal const string EnglishLangName = "en";
private static volatile DateTimeFormatInfo s_jajpDTFI;
private static volatile DateTimeFormatInfo s_zhtwDTFI;
InsertHash(temp, dateSeparatorOrTimeZoneOffset, TokenType.SEP_DateOrOffset, 0);
}
- String[] dateWords = null;
+ string[] dateWords = null;
DateTimeFormatInfoScanner scanner = null;
// We need to rescan the date words since we're always synthetic
// This is determined in DateTimeFormatInfoScanner. Use this flag to determine if we should treat date separator as ignorable symbol.
bool useDateSepAsIgnorableSymbol = false;
- String monthPostfix = null;
+ string monthPostfix = null;
if (dateWords != null)
{
// There are DateWords. It could be a real date word (such as "de"), or a monthPostfix.
AddMonthNames(temp, monthPostfix);
break;
case DateTimeFormatInfoScanner.IgnorableSymbolChar:
- String symbol = dateWords[i].Substring(1);
+ string symbol = dateWords[i].Substring(1);
InsertHash(temp, symbol, TokenType.IgnorableSymbol, 0);
if (this.DateSeparator.Trim(null).Equals(symbol))
{
{
for (int i = 1; i <= 13; i++)
{
- String str;
+ string str;
str = internalGetMonthName(i, MonthNameStyles.Genitive, false);
InsertHash(temp, str, TokenType.MonthToken, i);
}
{
for (int i = 1; i <= 13; i++)
{
- String str;
+ string str;
str = internalGetMonthName(i, MonthNameStyles.LeapYear, false);
InsertHash(temp, str, TokenType.MonthToken, i);
}
{
//String str = GetDayOfWeekNames()[i];
// We have to call public methods here to work with inherited DTFI.
- String str = GetDayName((DayOfWeek)i);
+ string str = GetDayName((DayOfWeek)i);
InsertHash(temp, str, TokenType.DayOfWeekToken, i);
str = GetAbbreviatedDayName((DayOfWeek)i);
// Japanese allows day of week forms like: "(Tue)"
for (int i = 0; i < 7; i++)
{
- String specialDayOfWeek = "(" + GetAbbreviatedDayName((DayOfWeek)i) + ")";
+ string specialDayOfWeek = "(" + GetAbbreviatedDayName((DayOfWeek)i) + ")";
InsertHash(temp, specialDayOfWeek, TokenType.DayOfWeekToken, i);
}
if (this.Calendar.GetType() != typeof(JapaneseCalendar))
// Add invariant month names and day names.
for (int i = 1; i <= 12; i++)
{
- String str;
+ string str;
// We have to call public methods here to work with inherited DTFI.
// Insert the month name first, so that they are at the front of abbreviated
// month names.
for (int i = 0; i < 7; i++)
{
// We have to call public methods here to work with inherited DTFI.
- String str = InvariantInfo.GetDayName((DayOfWeek)i);
+ string str = InvariantInfo.GetDayName((DayOfWeek)i);
InsertHash(temp, str, TokenType.DayOfWeekToken, i);
str = InvariantInfo.GetAbbreviatedDayName((DayOfWeek)i);
return (temp);
}
- private void AddMonthNames(TokenHashValue[] temp, String monthPostfix)
+ private void AddMonthNames(TokenHashValue[] temp, string monthPostfix)
{
for (int i = 1; i <= 13; i++)
{
- String str;
+ string str;
//str = internalGetMonthName(i, MonthNameStyles.Regular, false);
// We have to call public methods here to work with inherited DTFI.
// Insert the month name first, so that they are at the front of abbreviated
private static bool TryParseHebrewNumber(
ref __DTString str,
- out Boolean badFormat,
+ out bool badFormat,
out int number)
{
number = -1;
Debug.Assert(str.Index < str.Value.Length, "DateTimeFormatInfo.Tokenize(): start < value.Length");
char ch = str.m_current;
- bool isLetter = Char.IsLetter(ch);
+ bool isLetter = char.IsLetter(ch);
if (isLetter)
{
ch = this.Culture.TextInfo.ToLower(ch);
{
// Check word boundary. The next character should NOT be a letter.
char nextCh = str.Value[nextCharIndex];
- compareStrings = !(Char.IsLetter(nextCh));
+ compareStrings = !(char.IsLetter(nextCh));
}
}
return (false);
}
- private void InsertAtCurrentHashNode(TokenHashValue[] hashTable, String str, char ch, TokenType tokenType, int tokenValue, int pos, int hashcode, int hashProbe)
+ private void InsertAtCurrentHashNode(TokenHashValue[] hashTable, string str, char ch, TokenType tokenType, int tokenValue, int pos, int hashcode, int hashProbe)
{
// Remember the current slot.
TokenHashValue previousNode = hashTable[hashcode];
Debug.Fail("The hashtable is full. This should not happen.");
}
- private void InsertHash(TokenHashValue[] hashTable, String str, TokenType tokenType, int tokenValue)
+ private void InsertHash(TokenHashValue[] hashTable, string str, TokenType tokenType, int tokenValue)
{
// The month of the 13th month is allowed to be null, so make sure that we ignore null value here.
if (str == null || str.Length == 0)
int i = 0;
// If there is whitespace characters in the beginning and end of the string, trim them since whitespaces are skipped by
// DateTime.Parse().
- if (Char.IsWhiteSpace(str[0]) || Char.IsWhiteSpace(str[str.Length - 1]))
+ if (char.IsWhiteSpace(str[0]) || char.IsWhiteSpace(str[str.Length - 1]))
{
str = str.Trim(null); // Trim white space characters.
// Could have space for separators
internal class TokenHashValue
{
- internal String tokenString;
+ internal string tokenString;
internal TokenType tokenType;
internal int tokenValue;
- internal TokenHashValue(String tokenString, TokenType tokenType, int tokenValue)
+ internal TokenHashValue(string tokenString, TokenType tokenType, int tokenValue)
{
this.tokenString = tokenString;
this.tokenType = tokenType;
break;
}
}
- if (Char.IsLetter(ch) || ch == '\'' || ch == '.')
+ if (char.IsLetter(ch) || ch == '\'' || ch == '.')
{
break;
}
index++;
}
}
- else if (Char.IsWhiteSpace(ch))
+ else if (char.IsWhiteSpace(ch))
{
// Found a whitespace. We have to add the current date word/postfix.
AddDateWordOrPostfix(formatPostfix, dateWord.ToString());
i++;
break;
default:
- if (_ymdFlags == FoundDatePattern.FoundYMDPatternFlag && !Char.IsWhiteSpace(ch))
+ if (_ymdFlags == FoundDatePattern.FoundYMDPatternFlag && !char.IsWhiteSpace(ch))
{
// We are not seeing "." after YMD. Clear the flag.
_ymdFlags = FoundDatePattern.None;
// so we don't have to go to native code side.
for (int j = 0; j < array[i].Length; j++)
{
- if (Char.IsWhiteSpace(array[i][j]))
+ if (char.IsWhiteSpace(array[i][j]))
{
return true;
}
{
internal static class DateTimeParse
{
- internal const Int32 MaxDateTimeNumberDigits = 8;
+ internal const int MaxDateTimeNumberDigits = 8;
internal delegate bool MatchNumberDelegate(ref __DTString str, int digitLen, out int result);
if (nextCharIndex < str.Value.Length)
{
char nextCh = str.Value[nextCharIndex];
- if (Char.IsLetter(nextCh))
+ if (char.IsLetter(nextCh))
{
return (false);
}
char nextCh = str.Value[str.Index];
// Skip whitespace, but don't update the index unless we find a time zone marker
int whitespaceCount = 0;
- while (Char.IsWhiteSpace(nextCh) && str.Index + whitespaceCount < str.Length - 1)
+ while (char.IsWhiteSpace(nextCh) && str.Index + whitespaceCount < str.Length - 1)
{
whitespaceCount++;
nextCh = str.Value[str.Index + whitespaceCount];
// This is the lexer. Check the character at the current index, and put the found token in dtok and
// some raw date/time information in raw.
//
- private static Boolean Lex(DS dps, ref __DTString str, ref DateTimeToken dtok, ref DateTimeRawInfo raw, ref DateTimeResult result, ref DateTimeFormatInfo dtfi, DateTimeStyles styles)
+ private static bool Lex(DS dps, ref __DTString str, ref DateTimeToken dtok, ref DateTimeRawInfo raw, ref DateTimeResult result, ref DateTimeFormatInfo dtfi, DateTimeStyles styles)
{
TokenType tokenType;
int tokenValue;
}
break;
case TokenType.UnknownToken:
- if (Char.IsLetter(str.m_current))
+ if (char.IsLetter(str.m_current))
{
result.SetFailure(ParseFailureKind.FormatWithOriginalDateTimeAndParameter, nameof(SR.Format_UnknownDateTimeWord), str.Index);
LexTraceExit("0200", dps);
if ((str.m_current == '-' || str.m_current == '+') && ((result.flags & ParseFlags.TimeZoneUsed) == 0))
{
- Int32 originalIndex = str.Index;
+ int originalIndex = str.Index;
if (ParseTimeZone(ref str, ref result.timeZoneOffset))
{
result.flags |= ParseFlags.TimeZoneUsed;
return true;
}
- private static Boolean VerifyValidPunctuation(ref __DTString str)
+ private static bool VerifyValidPunctuation(ref __DTString str)
{
// Compatability Behavior. Allow trailing nulls and surrounding hashes
- Char ch = str.Value[str.Index];
+ char ch = str.Value[str.Index];
if (ch == '#')
{
bool foundStart = false;
return false;
}
}
- else if ((!Char.IsWhiteSpace(ch)))
+ else if ((!char.IsWhiteSpace(ch)))
{
// Anything other than whitespace outside hashes is invalid
if (!foundStart || foundEnd)
//
// Return 0 for YMD, 1 for MDY, 2 for DMY, otherwise -1.
//
- private static Boolean GetYearMonthDayOrder(string datePattern, DateTimeFormatInfo dtfi, out int order)
+ private static bool GetYearMonthDayOrder(string datePattern, DateTimeFormatInfo dtfi, out int order)
{
int yearOrder = -1;
int monthOrder = -1;
//
// Return 0 for YM, 1 for MY, otherwise -1.
//
- private static Boolean GetYearMonthOrder(string pattern, DateTimeFormatInfo dtfi, out int order)
+ private static bool GetYearMonthOrder(string pattern, DateTimeFormatInfo dtfi, out int order)
{
int yearOrder = -1;
int monthOrder = -1;
//
// Return 0 for MD, 1 for DM, otherwise -1.
//
- private static Boolean GetMonthDayOrder(string pattern, DateTimeFormatInfo dtfi, out int order)
+ private static bool GetMonthDayOrder(string pattern, DateTimeFormatInfo dtfi, out int order)
{
int monthOrder = -1;
int dayOrder = -1;
}
// Processing teriminal case: DS.DX_NN
- private static Boolean GetDayOfNN(ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
+ private static bool GetDayOfNN(ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
{
if ((result.flags & ParseFlags.HaveDate) != 0)
{
}
// Processing teriminal case: DS.DX_NNN
- private static Boolean GetDayOfNNN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
+ private static bool GetDayOfNNN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
{
if ((result.flags & ParseFlags.HaveDate) != 0)
{
return false;
}
- private static Boolean GetDayOfMN(ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
+ private static bool GetDayOfMN(ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
{
if ((result.flags & ParseFlags.HaveDate) != 0)
{
//
////////////////////////////////////////////////////////////////////////
- private static Boolean GetHebrewDayOfNM(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
+ private static bool GetHebrewDayOfNM(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
{
int monthDayOrder;
if (!GetMonthDayOrder(dtfi.MonthDayPattern, dtfi, out monthDayOrder))
return false;
}
- private static Boolean GetDayOfNM(ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
+ private static bool GetDayOfNM(ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
{
if ((result.flags & ParseFlags.HaveDate) != 0)
{
return true;
}
- private static Boolean GetDayOfMNN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
+ private static bool GetDayOfMNN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
{
if ((result.flags & ParseFlags.HaveDate) != 0)
{
return false;
}
- private static Boolean GetDayOfYNN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
+ private static bool GetDayOfYNN(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
{
if ((result.flags & ParseFlags.HaveDate) != 0)
{
return false;
}
- private static Boolean GetDayOfNNY(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
+ private static bool GetDayOfNNY(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
{
if ((result.flags & ParseFlags.HaveDate) != 0)
{
}
- private static Boolean GetDayOfYMN(ref DateTimeResult result, ref DateTimeRawInfo raw)
+ private static bool GetDayOfYMN(ref DateTimeResult result, ref DateTimeRawInfo raw)
{
if ((result.flags & ParseFlags.HaveDate) != 0)
{
return false;
}
- private static Boolean GetDayOfYN(ref DateTimeResult result, ref DateTimeRawInfo raw)
+ private static bool GetDayOfYN(ref DateTimeResult result, ref DateTimeRawInfo raw)
{
if ((result.flags & ParseFlags.HaveDate) != 0)
{
return false;
}
- private static Boolean GetDayOfYM(ref DateTimeResult result, ref DateTimeRawInfo raw)
+ private static bool GetDayOfYM(ref DateTimeResult result, ref DateTimeRawInfo raw)
{
if ((result.flags & ParseFlags.HaveDate) != 0)
{
//
// Adjust hour according to the time mark.
//
- private static Boolean AdjustHour(ref int hour, TM timeMark)
+ private static bool AdjustHour(ref int hour, TM timeMark)
{
if (timeMark != TM.NotSet)
{
return true;
}
- private static Boolean GetTimeOfN(ref DateTimeResult result, ref DateTimeRawInfo raw)
+ private static bool GetTimeOfN(ref DateTimeResult result, ref DateTimeRawInfo raw)
{
if ((result.flags & ParseFlags.HaveTime) != 0)
{
return true;
}
- private static Boolean GetTimeOfNN(ref DateTimeResult result, ref DateTimeRawInfo raw)
+ private static bool GetTimeOfNN(ref DateTimeResult result, ref DateTimeRawInfo raw)
{
Debug.Assert(raw.numCount >= 2, "raw.numCount >= 2");
if ((result.flags & ParseFlags.HaveTime) != 0)
return true;
}
- private static Boolean GetTimeOfNNN(ref DateTimeResult result, ref DateTimeRawInfo raw)
+ private static bool GetTimeOfNNN(ref DateTimeResult result, ref DateTimeRawInfo raw)
{
if ((result.flags & ParseFlags.HaveTime) != 0)
{
//
// Processing terminal state: A Date suffix followed by one number.
//
- private static Boolean GetDateOfDSN(ref DateTimeResult result, ref DateTimeRawInfo raw)
+ private static bool GetDateOfDSN(ref DateTimeResult result, ref DateTimeRawInfo raw)
{
if (raw.numCount != 1 || result.Day != -1)
{
return true;
}
- private static Boolean GetDateOfNDS(ref DateTimeResult result, ref DateTimeRawInfo raw)
+ private static bool GetDateOfNDS(ref DateTimeResult result, ref DateTimeRawInfo raw)
{
if (result.Month == -1)
{
return true;
}
- private static Boolean GetDateOfNNDS(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
+ private static bool GetDateOfNNDS(ref DateTimeResult result, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
{
// For partial CJK Dates, the only valid formats are with a specified year, followed by two numbers, which
// will be the Month and Day, and with a specified Month, when the numbers are either the year and day or
//
////////////////////////////////////////////////////////////////////////
- internal static Boolean ProcessHebrewTerminalState(DS dps, ref __DTString str, ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
+ internal static bool ProcessHebrewTerminalState(DS dps, ref __DTString str, ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
{
// The following are accepted terminal state for Hebrew date.
switch (dps)
// A terminal state has been reached, call the appropriate function to fill in the parsing result.
// Return true if the state is a terminal state.
//
- internal static Boolean ProcessTerminalState(DS dps, ref __DTString str, ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
+ internal static bool ProcessTerminalState(DS dps, ref __DTString str, ref DateTimeResult result, ref DateTimeStyles styles, ref DateTimeRawInfo raw, DateTimeFormatInfo dtfi)
{
bool passed = true;
switch (dps)
DateTimeRawInfo raw = new DateTimeRawInfo(); // The buffer to store temporary parsing information.
unsafe
{
- Int32* numberPointer = stackalloc Int32[3];
+ int* numberPointer = stackalloc int[3];
raw.Init(numberPointer);
}
raw.hasSameDateAndTimeSeparators = dtfi.DateSeparator.Equals(dtfi.TimeSeparator, StringComparison.Ordinal);
// Handles time zone adjustments and sets DateTimeKind values as required by the styles
- private static Boolean DetermineTimeZoneAdjustments(ref __DTString str, ref DateTimeResult result, DateTimeStyles styles, Boolean bTimeOnly)
+ private static bool DetermineTimeZoneAdjustments(ref __DTString str, ref DateTimeResult result, DateTimeStyles styles, bool bTimeOnly)
{
if ((result.flags & ParseFlags.CaptureOffset) != 0)
{
}
else
{
- Int64 offsetTicks = result.timeZoneOffset.Ticks;
+ long offsetTicks = result.timeZoneOffset.Ticks;
// the DateTime offset must be within +- 14:00 hours.
if (offsetTicks < DateTimeOffset.MinOffset || offsetTicks > DateTimeOffset.MaxOffset)
}
// Apply validation and adjustments specific to DateTimeOffset
- private static Boolean DateTimeOffsetTimeZonePostProcessing(ref __DTString str, ref DateTimeResult result, DateTimeStyles styles)
+ private static bool DateTimeOffsetTimeZonePostProcessing(ref __DTString str, ref DateTimeResult result, DateTimeStyles styles)
{
// For DateTimeOffset, default to the Utc or Local offset when an offset was not specified by
// the input string.
}
}
- Int64 offsetTicks = result.timeZoneOffset.Ticks;
+ long offsetTicks = result.timeZoneOffset.Ticks;
// there should be no overflow, because the offset can be no more than -+100 hours and the date already
// fits within a DateTime.
- Int64 utcTicks = result.parsedDate.Ticks - offsetTicks;
+ long utcTicks = result.parsedDate.Ticks - offsetTicks;
// For DateTimeOffset, both the parsed time and the corresponding UTC value must be within the boundaries
// of a DateTime instance.
if (((result.flags & ParseFlags.TimeZoneUsed) == 0) && ((styles & DateTimeStyles.AssumeUniversal) == 0))
{
// Handle the special case where the timeZoneOffset was defaulted to Local
- Boolean toUtcResult = AdjustTimeZoneToUniversal(ref result);
+ bool toUtcResult = AdjustTimeZoneToUniversal(ref result);
result.timeZoneOffset = TimeSpan.Zero;
return toUtcResult;
}
// the time is 2001/06/08 14:00, and timeZoneOffset = -07:00.
// The result will be "2001/06/08 21:00"
//
- private static Boolean AdjustTimeZoneToUniversal(ref DateTimeResult result)
+ private static bool AdjustTimeZoneToUniversal(ref DateTimeResult result)
{
long resultTicks = result.parsedDate.Ticks;
resultTicks -= result.timeZoneOffset.Ticks;
// the time is 2001/06/08 14:00, and timeZoneOffset = -05:00.
// The result will be "2001/06/08 11:00"
//
- private static Boolean AdjustTimeZoneToLocal(ref DateTimeResult result, bool bTimeOnly)
+ private static bool AdjustTimeZoneToLocal(ref DateTimeResult result, bool bTimeOnly)
{
long resultTicks = result.parsedDate.Ticks;
// Convert to local ticks
TimeZoneInfo tz = TimeZoneInfo.Local;
- Boolean isAmbiguousLocalDst = false;
+ bool isAmbiguousLocalDst = false;
if (resultTicks < Calendar.TicksPerDay)
{
//
{
// Convert the GMT time to local time.
DateTime utcDt = new DateTime(resultTicks, DateTimeKind.Utc);
- Boolean isDaylightSavings = false;
+ bool isDaylightSavings = false;
resultTicks += TimeZoneInfo.GetUtcOffsetFromUtc(utcDt, TimeZoneInfo.Local, out isDaylightSavings, out isAmbiguousLocalDst).Ticks;
}
}
}
}
}
- else if (Char.IsWhiteSpace(m_current))
+ else if (char.IsWhiteSpace(m_current))
{
// Just skip to the next character.
while (++Index < Length)
{
m_current = Value[Index];
- if (!(Char.IsWhiteSpace(m_current)))
+ if (!(char.IsWhiteSpace(m_current)))
{
goto Start;
}
Index + target.Length <= Length &&
m_info.Compare(Value.Slice(Index, target.Length), target, CompareOptions.IgnoreCase) == 0;
- private static readonly Char[] WhiteSpaceChecks = new Char[] { ' ', '\u00A0' };
+ private static readonly char[] WhiteSpaceChecks = new char[] { ' ', '\u00A0' };
internal bool MatchSpecifiedWords(string target, bool checkWordBoundary, ref int matchLength)
{
else
{
// Make sure we also have whitespace in the input string
- if (!Char.IsWhiteSpace(Value[thisPosition + segmentLength]))
+ if (!char.IsWhiteSpace(Value[thisPosition + segmentLength]))
{
return false;
}
// Skip past multiple whitespace
- while (thisPosition < Value.Length && Char.IsWhiteSpace(Value[thisPosition]))
+ while (thisPosition < Value.Length && char.IsWhiteSpace(Value[thisPosition]))
{
thisPosition++;
matchLength++;
int nextCharIndex = Index + matchLength;
if (nextCharIndex < Value.Length)
{
- if (Char.IsLetter(Value[nextCharIndex]))
+ if (char.IsLetter(Value[nextCharIndex]))
{
return (false);
}
while (Index + 1 < Length)
{
char ch = Value[Index + 1];
- if (!Char.IsWhiteSpace(ch))
+ if (!char.IsWhiteSpace(ch))
{
return;
}
return (false);
}
- if (!Char.IsWhiteSpace(m_current))
+ if (!char.IsWhiteSpace(m_current))
{
return (true);
}
while (++Index < Length)
{
m_current = Value[Index];
- if (!Char.IsWhiteSpace(m_current))
+ if (!char.IsWhiteSpace(m_current))
{
return (true);
}
internal void TrimTail()
{
int i = Length - 1;
- while (i >= 0 && Char.IsWhiteSpace(Value[i]))
+ while (i >= 0 && char.IsWhiteSpace(Value[i]))
{
i--;
}
while (Index + sub.length < Length)
{
DTSubStringType currentType;
- Char ch = Value[Index + sub.length];
+ char ch = Value[Index + sub.length];
if (ch >= '0' && ch <= '9')
{
currentType = DTSubStringType.Number;
internal ref struct DTSubString
{
internal ReadOnlySpan<char> s;
- internal Int32 index;
- internal Int32 length;
+ internal int index;
+ internal int length;
internal DTSubStringType type;
- internal Int32 value;
+ internal int value;
- internal Char this[Int32 relativeIndex]
+ internal char this[int relativeIndex]
{
get
{
//
////////////////////////////////////////////////////////////////////////////
- internal static String ToString(int Number)
+ internal static string ToString(int Number)
{
char cTens = '\x0';
char cUnits; // tens and units chars
{
private int GetHijriDateAdjustment()
{
- if (_hijriAdvance == Int32.MinValue)
+ if (_hijriAdvance == int.MinValue)
{
// Never been set before. Use the system value from registry.
_hijriAdvance = GetAdvanceHijriDate();
{
try
{
- Object value = key.InternalGetValue(HijriAdvanceRegKeyEntry, null, false, false);
+ object value = key.InternalGetValue(HijriAdvanceRegKeyEntry, null, false, false);
if (value == null)
{
return (0);
{
try
{
- int advance = Int32.Parse(str.AsSpan(HijriAdvanceRegKeyEntry.Length), provider:CultureInfo.InvariantCulture);
+ int advance = int.Parse(str.AsSpan(HijriAdvanceRegKeyEntry.Length), provider:CultureInfo.InvariantCulture);
if ((advance >= MinAdvancedHijri) && (advance <= MaxAdvancedHijri))
{
hijriAdvance = advance;
internal static readonly int[] HijriMonthDays = { 0, 30, 59, 89, 118, 148, 177, 207, 236, 266, 295, 325, 355 };
- private int _hijriAdvance = Int32.MinValue;
+ private int _hijriAdvance = int.MinValue;
// DateTime.MaxValue = Hijri calendar (year:9666, month: 4, day: 3).
internal const int MaxCalendarYear = 9666;
{
get
{
- if (_hijriAdvance == Int32.MinValue)
+ if (_hijriAdvance == int.MinValue)
{
// Never been set before. Use the system value from registry.
_hijriAdvance = GetHijriDateAdjustment();
// Check last char
int iTest = iNextDot - 1;
- if (Char.IsLowSurrogate(unicode, iTest))
+ if (char.IsLowSurrogate(unicode, iTest))
{
iTest--;
}
for (basicCount = iAfterLastDot; basicCount < iNextDot; basicCount++)
{
// Can't be lonely surrogate because it would've thrown in normalization
- Debug.Assert(Char.IsLowSurrogate(unicode, basicCount) == false, "[IdnMapping.punycode_encode]Unexpected low surrogate");
+ Debug.Assert(char.IsLowSurrogate(unicode, basicCount) == false, "[IdnMapping.punycode_encode]Unexpected low surrogate");
// Double check our bidi rules
BidiCategory testBidi = CharUnicodeInfo.GetBidiCategory(unicode, basicCount);
numProcessed++;
}
// If its a surrogate, skip the next since our bidi category tester doesn't handle it.
- else if (Char.IsSurrogatePair(unicode, basicCount))
+ else if (char.IsSurrogatePair(unicode, basicCount))
basicCount++;
}
j < iNextDot;
j += IsSupplementary(test) ? 2 : 1)
{
- test = Char.ConvertToUtf32(unicode, j);
+ test = char.ConvertToUtf32(unicode, j);
if (test >= n && test < m) m = test;
}
for (j = iAfterLastDot; j < iNextDot; j+= IsSupplementary(test) ? 2 : 1)
{
// Make sure we're aware of surrogates
- test = Char.ConvertToUtf32(unicode, j);
+ test = char.ConvertToUtf32(unicode, j);
// Adjust for character position (only the chars in our string already, some
// haven't been processed.
// insert n at position i of the output: Really tricky if we have surrogates
int iUseInsertLocation;
- String strTemp = Char.ConvertFromUtf32(n);
+ string strTemp = char.ConvertFromUtf32(n);
// If we have supplimentary characters
if (numSurrogatePairs > 0)
// If its a surrogate, we have to go one more
if (iUseInsertLocation >= output.Length)
throw new ArgumentException(SR.Argument_IdnBadPunycode, nameof(ascii));
- if (Char.IsSurrogate(output[iUseInsertLocation]))
+ if (char.IsSurrogate(output[iUseInsertLocation]))
iUseInsertLocation++;
}
}
for (int iTest = iOutputAfterLastDot; iTest < output.Length; iTest++)
{
// This might happen if we run into a pair
- if (Char.IsLowSurrogate(output[iTest]))
+ if (char.IsLowSurrogate(output[iTest]))
continue;
// Check to see if its LTR
internal const long TicksPerMillisecond = 10000;
internal const long TicksPerTenthSecond = TicksPerMillisecond * 100;
internal const long TicksPerSecond = TicksPerMillisecond * 1000; // 10,000,000
- internal const long MaxSeconds = Int64.MaxValue / TicksPerSecond;
- internal const long MinSeconds = Int64.MinValue / TicksPerSecond;
+ internal const long MaxSeconds = long.MaxValue / TicksPerSecond;
+ internal const long MinSeconds = long.MinValue / TicksPerSecond;
private const int DaysPerYear = 365;
private const int DaysPer4Years = DaysPerYear * 4 + 1; // 1461
private const int DaysPer100Years = DaysPer4Years * 25 - 1; // 36524
private const long TicksPerDay = TicksPerHour * 24;
internal const long MaxTicks = DaysTo10000 * TicksPerDay - 1;
internal const long MinTicks = 0;
- internal const long MaxMilliSeconds = Int64.MaxValue / TicksPerMillisecond;
- internal const long MinMilliSeconds = Int64.MinValue / TicksPerMillisecond;
+ internal const long MaxMilliSeconds = long.MaxValue / TicksPerMillisecond;
+ internal const long MinMilliSeconds = long.MinValue / TicksPerMillisecond;
internal const int StringBuilderDefaultCapacity = 16;
- internal const Int64 MaxOffset = TimeSpan.TicksPerHour * 14;
- internal const Int64 MinOffset = -MaxOffset;
+ internal const long MaxOffset = TimeSpan.TicksPerHour * 14;
+ internal const long MinOffset = -MaxOffset;
}
}
if (key == null) return null;
// Look up the values in our reg key
- String[] valueNames = key.GetValueNames();
+ string[] valueNames = key.GetValueNames();
if (valueNames != null && valueNames.Length > 0)
{
registryEraRanges = new EraInfo[valueNames.Length];
// . is a delimiter, but the value of . doesn't matter.
// '_' marks the space between the japanese era name, japanese abbreviated era name
// english name, and abbreviated english names.
- private static EraInfo GetEraFromValue(String value, String data)
+ private static EraInfo GetEraFromValue(string value, string data)
{
// Need inputs
if (value == null || data == null) return null;
int day;
ReadOnlySpan<char> valueSpan = value.AsSpan();
- if (!Int32.TryParse(valueSpan.Slice(0, 4), NumberStyles.None, NumberFormatInfo.InvariantInfo, out year) ||
- !Int32.TryParse(valueSpan.Slice(5, 2), NumberStyles.None, NumberFormatInfo.InvariantInfo, out month) ||
- !Int32.TryParse(valueSpan.Slice(8, 2), NumberStyles.None, NumberFormatInfo.InvariantInfo, out day))
+ if (!int.TryParse(valueSpan.Slice(0, 4), NumberStyles.None, NumberFormatInfo.InvariantInfo, out year) ||
+ !int.TryParse(valueSpan.Slice(5, 2), NumberStyles.None, NumberFormatInfo.InvariantInfo, out month) ||
+ !int.TryParse(valueSpan.Slice(8, 2), NumberStyles.None, NumberFormatInfo.InvariantInfo, out day))
{
// Couldn't convert integer, fail
return null;
// Get Strings
//
// Needs to be a certain length e_a_E_A at least (7 chars, exactly 4 groups)
- String[] names = data.Split('_');
+ string[] names = data.Split('_');
// Should have exactly 4 parts
// 0 - Era Name
// PAL Layer ends here
- private static string[] s_japaneseErasEnglishNames = new String[] { "M", "T", "S", "H" };
+ private static string[] s_japaneseErasEnglishNames = new string[] { "M", "T", "S", "H" };
private static string GetJapaneseEnglishEraName(int era)
{
{
throw new ArgumentOutOfRangeException(
"year",
- String.Format(
+ string.Format(
CultureInfo.CurrentCulture,
SR.ArgumentOutOfRange_Range,
MIN_LUNISOLAR_YEAR,
{
throw new ArgumentOutOfRangeException(
nameof(year),
- String.Format(
+ string.Format(
CultureInfo.CurrentCulture,
SR.ArgumentOutOfRange_Range, MIN_LUNISOLAR_YEAR, MAX_LUNISOLAR_YEAR));
}
}
}
- public Object Clone()
+ public object Clone()
{
NumberFormatInfo n = (NumberFormatInfo)MemberwiseClone();
n.isReadOnly = false;
}
VerifyWritable();
- Int32[] inputSizes = (Int32[])value.Clone();
+ int[] inputSizes = (int[])value.Clone();
CheckGroupSize(nameof(CurrencyGroupSizes), inputSizes);
currencyGroupSizes = inputSizes;
}
}
VerifyWritable();
- Int32[] inputSizes = (Int32[])value.Clone();
+ int[] inputSizes = (int[])value.Clone();
CheckGroupSize(nameof(NumberGroupSizes), inputSizes);
numberGroupSizes = inputSizes;
}
SR.ArgumentNull_Obj);
}
VerifyWritable();
- Int32[] inputSizes = (Int32[])value.Clone();
+ int[] inputSizes = (int[])value.Clone();
CheckGroupSize(nameof(PercentGroupSizes), inputSizes);
percentGroupSizes = inputSizes;
}
}
}
- public Object GetFormat(Type formatType)
+ public object GetFormat(Type formatType)
{
return formatType == typeof(NumberFormatInfo) ? this : null;
}
// (ie: en-US)
//
////////////////////////////////////////////////////////////////////////
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
RegionInfo that = value as RegionInfo;
if (that != null)
// The following constructor is designed to be called from CompareInfo to get the
// the sort key of specific string for synthetic culture
//
- internal SortKey(String localeName, String str, CompareOptions options, byte[] keyData)
+ internal SortKey(string localeName, string str, CompareOptions options, byte[] keyData)
{
_keyData = keyData;
_localeName = localeName;
// of SortKey.
//
////////////////////////////////////////////////////////////////////////
- public virtual String OriginalString
+ public virtual string OriginalString
{
get
{
// or not object refers to the same SortKey as the current instance.
//
////////////////////////////////////////////////////////////////////////
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
SortKey that = value as SortKey;
// SortKey.
//
////////////////////////////////////////////////////////////////////////
- public override String ToString()
+ public override string ToString()
{
return ("SortKey - " + _localeName + ", " + _options + ", " + _string);
}
this.String = value;
}
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
StringInfo that = value as StringInfo;
if (that != null)
public class TextElementEnumerator : IEnumerator
{
- private String _str;
+ private string _str;
private int _index;
private int _startIndex;
private int _charLen; // The next abstract char to look at after MoveNext() is called. It could be 1 or 2, depending on if it is a surrogate or not.
- internal TextElementEnumerator(String str, int startIndex, int strLen)
+ internal TextElementEnumerator(string str, int startIndex, int strLen)
{
Debug.Assert(str != null, "TextElementEnumerator(): str != null");
Debug.Assert(startIndex >= 0 && strLen >= 0, "TextElementEnumerator(): startIndex >= 0 && strLen >= 0");
// Get the current text element.
//
- public Object Current
+ public object Current
{
get
{
// Get the current text element.
//
- public String GetTextElement()
+ public string GetTextElement()
{
if (_index == _startIndex)
{
FinishInitialization();
}
- void IDeserializationCallback.OnDeserialization(Object sender)
+ void IDeserializationCallback.OnDeserialization(object sender)
{
throw new PlatformNotSupportedException();
}
// or not object refers to the same CultureInfo as the current instance.
//
////////////////////////////////////////////////////////////////////////
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
TextInfo that = obj as TextInfo;
WaitHandle AsyncWaitHandle { get; }
- Object AsyncState { get; }
+ object AsyncState { get; }
bool CompletedSynchronously { get; }
}
// if this is equal to object, or a value greater than zero
// if this is greater than object.
//
- int CompareTo(Object obj);
+ int CompareTo(object obj);
}
// Generic version of IComparable.
ulong ToUInt64(IFormatProvider provider);
float ToSingle(IFormatProvider provider);
double ToDouble(IFormatProvider provider);
- Decimal ToDecimal(IFormatProvider provider);
+ decimal ToDecimal(IFormatProvider provider);
DateTime ToDateTime(IFormatProvider provider);
- String ToString(IFormatProvider provider);
- Object ToType(Type conversionType, IFormatProvider provider);
+ string ToString(IFormatProvider provider);
+ object ToType(Type conversionType, IFormatProvider provider);
}
}
public interface ICustomFormatter
{
// Interface does not need to be marked with the serializable attribute
- String Format(String format, Object arg, IFormatProvider formatProvider);
+ string Format(string format, object arg, IFormatProvider formatProvider);
}
}
public interface IFormatProvider
{
// Interface does not need to be marked with the serializable attribute
- Object GetFormat(Type formatType);
+ object GetFormat(Type formatType);
}
}
{
public interface IFormattable
{
- String ToString(String format, IFormatProvider formatProvider);
+ string ToString(string format, IFormatProvider formatProvider);
}
}
//
public unsafe virtual void Write(char ch)
{
- if (Char.IsSurrogate(ch))
+ if (char.IsSurrogate(ch))
throw new ArgumentException(SR.Arg_SurrogatesNotAllowedAsSingleChar);
Debug.Assert(_encoding.GetMaxByteCount(1) <= 16, "_encoding.GetMaxByteCount(1) <= 16)");
public virtual void Write(decimal value)
{
- Decimal.GetBytes(value, _buffer);
+ decimal.GetBytes(value, _buffer);
OutStream.Write(_buffer, 0, 16);
}
// a four-byte unsigned integer, and then writes that many characters
// to the stream.
//
- public unsafe virtual void Write(String value)
+ public unsafe virtual void Write(string value)
{
if (value == null)
throw new ArgumentNullException(nameof(value));
HResult = HResults.COR_E_IO;
}
- public IOException(String message)
+ public IOException(string message)
: base(message)
{
HResult = HResults.COR_E_IO;
}
- public IOException(String message, int hresult)
+ public IOException(string message, int hresult)
: base(message)
{
HResult = hresult;
}
- public IOException(String message, Exception innerException)
+ public IOException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_IO;
return n;
}
- public override Task<int> ReadAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
if (buffer == null)
throw new ArgumentNullException(nameof(buffer), SR.ArgumentNull_Buffer);
_position = i;
}
- public override Task WriteAsync(Byte[] buffer, int offset, int count, CancellationToken cancellationToken)
+ public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
if (buffer == null)
throw new ArgumentNullException(nameof(buffer), SR.ArgumentNull_Buffer);
return new ManualResetEvent(false);
}
- public virtual IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, Object state)
+ public virtual IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
return BeginReadInternal(buffer, offset, count, callback, state, serializeAsynchronously: false, apm: true);
}
internal IAsyncResult BeginReadInternal(
- byte[] buffer, int offset, int count, AsyncCallback callback, Object state,
+ byte[] buffer, int offset, int count, AsyncCallback callback, object state,
bool serializeAsynchronously, bool apm)
{
if (!CanRead) throw Error.GetReadNotSupported();
- public virtual IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, Object state)
+ public virtual IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
return BeginWriteInternal(buffer, offset, count, callback, state, serializeAsynchronously: false, apm: true);
}
internal IAsyncResult BeginWriteInternal(
- byte[] buffer, int offset, int count, AsyncCallback callback, Object state,
+ byte[] buffer, int offset, int count, AsyncCallback callback, object state,
bool serializeAsynchronously, bool apm)
{
if (!CanWrite) throw Error.GetWriteNotSupported();
{
}
- internal IAsyncResult BlockingBeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, Object state)
+ internal IAsyncResult BlockingBeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
// To avoid a race with a stream's position pointer & generating conditions
// with internal buffer indexes in our own streams that
return SynchronousAsyncResult.EndRead(asyncResult);
}
- internal IAsyncResult BlockingBeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, Object state)
+ internal IAsyncResult BlockingBeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
// To avoid a race condition with a stream's position pointer & generating conditions
// with internal buffer indexes in our own streams that
Task.CompletedTask;
}
- public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, Object state)
+ public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (!CanRead) throw Error.GetReadNotSupported();
return BlockingEndRead(asyncResult);
}
- public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, Object state)
+ public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (!CanWrite) throw Error.GetWriteNotSupported();
/// <summary>Used as the IAsyncResult object when using asynchronous IO methods on the base Stream class.</summary>
private sealed class SynchronousAsyncResult : IAsyncResult
{
- private readonly Object _stateObject;
+ private readonly object _stateObject;
private readonly bool _isWrite;
private ManualResetEvent _waitHandle;
private ExceptionDispatchInfo _exceptionInfo;
private bool _endXxxCalled;
private int _bytesRead;
- internal SynchronousAsyncResult(int bytesRead, Object asyncStateObject)
+ internal SynchronousAsyncResult(int bytesRead, object asyncStateObject)
{
_bytesRead = bytesRead;
_stateObject = asyncStateObject;
//_isWrite = false;
}
- internal SynchronousAsyncResult(Object asyncStateObject)
+ internal SynchronousAsyncResult(object asyncStateObject)
{
_stateObject = asyncStateObject;
_isWrite = true;
}
- internal SynchronousAsyncResult(Exception ex, Object asyncStateObject, bool isWrite)
+ internal SynchronousAsyncResult(Exception ex, object asyncStateObject, bool isWrite)
{
_exceptionInfo = ExceptionDispatchInfo.Capture(ex);
_stateObject = asyncStateObject;
}
}
- public Object AsyncState
+ public object AsyncState
{
get { return _stateObject; }
}
return _stream.ReadByte();
}
- public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, Object state)
+ public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
#if CORERT
throw new NotImplementedException(); // TODO: https://github.com/dotnet/corert/issues/3251
_stream.WriteByte(b);
}
- public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, Object state)
+ public override IAsyncResult BeginWrite(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
#if CORERT
throw new NotImplementedException(); // TODO: https://github.com/dotnet/corert/issues/3251
// data read in, let's try writing directly to the user's buffer.
bool readToUserBuffer = false;
- Byte[] tmpByteBuffer = _byteBuffer;
+ byte[] tmpByteBuffer = _byteBuffer;
Stream tmpStream = _stream;
int count = buffer.Length;
{
_charLen = 0;
_charPos = 0;
- Byte[] tmpByteBuffer = _byteBuffer;
+ byte[] tmpByteBuffer = _byteBuffer;
Stream tmpStream = _stream;
if (!_checkPreamble)
// to ensure performant access inside the state machine that corresponds this async method.
private static async Task FlushAsyncInternal(StreamWriter _this, bool flushStream, bool flushEncoder,
char[] charBuffer, int charPos, bool haveWrittenPreamble,
- Encoding encoding, Encoder encoder, Byte[] byteBuffer, Stream stream, CancellationToken cancellationToken)
+ Encoding encoding, Encoder encoder, byte[] byteBuffer, Stream stream, CancellationToken cancellationToken)
{
if (!haveWrittenPreamble)
{
#region Task based Async APIs
public virtual Task<string> ReadLineAsync()
{
- return Task<String>.Factory.StartNew(state =>
+ return Task<string>.Factory.StartNew(state =>
{
return ((TextReader)state).ReadLine();
},
// Writes the text representation of an integer to the text stream. The
// text representation of the given value is produced by calling the
- // Int32.ToString() method.
+ // int.ToString() method.
//
public virtual void Write(int value)
{
// Writes the text representation of an integer to the text stream. The
// text representation of the given value is produced by calling the
- // UInt32.ToString() method.
+ // uint.ToString() method.
//
[CLSCompliant(false)]
public virtual void Write(uint value)
// Writes the text representation of a long to the text stream. The
// text representation of the given value is produced by calling the
- // Int64.ToString() method.
+ // long.ToString() method.
//
public virtual void Write(long value)
{
// Writes the text representation of an unsigned long to the text
// stream. The text representation of the given value is produced
- // by calling the UInt64.ToString() method.
+ // by calling the ulong.ToString() method.
//
[CLSCompliant(false)]
public virtual void Write(ulong value)
}
// Writes out a formatted string. Uses the same semantics as
- // String.Format.
+ // string.Format.
//
public virtual void Write(string format, object arg0)
{
}
// Writes out a formatted string. Uses the same semantics as
- // String.Format.
+ // string.Format.
//
public virtual void Write(string format, object arg0, object arg1)
{
}
// Writes out a formatted string. Uses the same semantics as
- // String.Format.
+ // string.Format.
//
public virtual void Write(string format, object arg0, object arg1, object arg2)
{
}
// Writes out a formatted string. Uses the same semantics as
- // String.Format.
+ // string.Format.
//
public virtual void Write(string format, params object[] arg)
{
}
// Writes out a formatted string and a new line. Uses the same
- // semantics as String.Format.
+ // semantics as string.Format.
//
public virtual void WriteLine(string format, object arg0)
{
}
// Writes out a formatted string and a new line. Uses the same
- // semantics as String.Format.
+ // semantics as string.Format.
//
public virtual void WriteLine(string format, object arg0, object arg1)
{
}
// Writes out a formatted string and a new line. Uses the same
- // semantics as String.Format.
+ // semantics as string.Format.
//
public virtual void WriteLine(string format, object arg0, object arg1, object arg2)
{
}
// Writes out a formatted string and a new line. Uses the same
- // semantics as String.Format.
+ // semantics as string.Format.
//
public virtual void WriteLine(string format, params object[] arg)
{
public override void Write(double value) => _out.Write(value);
[MethodImpl(MethodImplOptions.Synchronized)]
- public override void Write(Decimal value) => _out.Write(value);
+ public override void Write(decimal value) => _out.Write(value);
[MethodImpl(MethodImplOptions.Synchronized)]
public override void Write(string value) => _out.Write(value);
private long _offset;
private FileAccess _access;
private bool _isOpen;
- private Task<Int32> _lastReadTask; // The last successful task returned from ReadAsync
+ private Task<int> _lastReadTask; // The last successful task returned from ReadAsync
/// <summary>
/// Creates a closed stream.
/// <param name="count">Maximum number of bytes to read.</param>
/// <param name="cancellationToken">Token that can be used to cancel this operation.</param>
/// <returns>Task that can be used to access the number of bytes actually read.</returns>
- public override Task<Int32> ReadAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken)
+ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
if (buffer == null)
throw new ArgumentNullException(nameof(buffer), SR.ArgumentNull_Buffer);
throw new ArgumentException(SR.Argument_InvalidOffLen);
if (cancellationToken.IsCancellationRequested)
- return Task.FromCanceled<Int32>(cancellationToken);
+ return Task.FromCanceled<int>(cancellationToken);
try
{
- Int32 n = Read(buffer, offset, count);
- Task<Int32> t = _lastReadTask;
+ int n = Read(buffer, offset, count);
+ Task<int> t = _lastReadTask;
return (t != null && t.Result == n) ? t : (_lastReadTask = Task.FromResult<Int32>(n));
}
catch (Exception ex)
{
Debug.Assert(!(ex is OperationCanceledException));
- return Task.FromException<Int32>(ex);
+ return Task.FromException<int>(ex);
}
}
/// <param name="count">Number of bytes to write.</param>
/// <param name="cancellationToken">Token that can be used to cancel the operation.</param>
/// <returns>Task that can be awaited </returns>
- public override Task WriteAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken)
+ public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
if (buffer == null)
throw new ArgumentNullException(nameof(buffer), SR.ArgumentNull_Buffer);
stream.Write(buffer, 0, buffer.Length);
}
- public override void SetLength(Int64 value)
+ public override void SetLength(long value)
{
// This was probably meant to call _unmanagedStream.SetLength(value), but it was forgotten in V.4.0.
// Now this results in a call to the base which touches the underlying array which is never actually used.
}
- public override Task CopyToAsync(Stream destination, Int32 bufferSize, CancellationToken cancellationToken)
+ public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken)
{
// The parameter checks must be in sync with the base version:
if (destination == null)
}
- public override Task<Int32> ReadAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken)
+ public override Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
return _unmanagedStream.ReadAsync(buffer, offset, count, cancellationToken);
}
}
- public override Task WriteAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken)
+ public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
{
return _unmanagedStream.WriteAsync(buffer, offset, count, cancellationToken);
}
HResult = HResults.COR_E_INDEXOUTOFRANGE;
}
- public IndexOutOfRangeException(String message)
+ public IndexOutOfRangeException(string message)
: base(message)
{
HResult = HResults.COR_E_INDEXOUTOFRANGE;
}
- public IndexOutOfRangeException(String message, Exception innerException)
+ public IndexOutOfRangeException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_INDEXOUTOFRANGE;
HResult = HResults.COR_E_INSUFFICIENTEXECUTIONSTACK;
}
- public InsufficientExecutionStackException(String message)
+ public InsufficientExecutionStackException(string message)
: base(message)
{
HResult = HResults.COR_E_INSUFFICIENTEXECUTIONSTACK;
}
- public InsufficientExecutionStackException(String message, Exception innerException)
+ public InsufficientExecutionStackException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_INSUFFICIENTEXECUTIONSTACK;
HResult = HResults.COR_E_INSUFFICIENTMEMORY;
}
- public InsufficientMemoryException(String message)
+ public InsufficientMemoryException(string message)
: base(message)
{
HResult = HResults.COR_E_INSUFFICIENTMEMORY;
}
- public InsufficientMemoryException(String message, Exception innerException)
+ public InsufficientMemoryException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_INSUFFICIENTMEMORY;
[Serializable]
[StructLayout(LayoutKind.Sequential)]
[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public struct Int16 : IComparable, IConvertible, IFormattable, IComparable<Int16>, IEquatable<Int16>, ISpanFormattable
+ public struct Int16 : IComparable, IConvertible, IFormattable, IComparable<short>, IEquatable<short>, ISpanFormattable
{
private short m_value; // Do not rename (binary serialization)
// null is considered to be less than any instance.
// If object is not of type Int16, this method throws an ArgumentException.
//
- public int CompareTo(Object value)
+ public int CompareTo(object value)
{
if (value == null)
{
return 1;
}
- if (value is Int16)
+ if (value is short)
{
- return m_value - ((Int16)value).m_value;
+ return m_value - ((short)value).m_value;
}
throw new ArgumentException(SR.Arg_MustBeInt16);
}
- public int CompareTo(Int16 value)
+ public int CompareTo(short value)
{
return m_value - value;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
- if (!(obj is Int16))
+ if (!(obj is short))
{
return false;
}
- return m_value == ((Int16)obj).m_value;
+ return m_value == ((short)obj).m_value;
}
[NonVersionable]
- public bool Equals(Int16 obj)
+ public bool Equals(short obj)
{
return m_value == obj;
}
}
- public override String ToString()
+ public override string ToString()
{
return Number.FormatInt32(m_value, null, null);
}
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
return Number.FormatInt32(m_value, null, provider);
}
- public String ToString(String format)
+ public string ToString(string format)
{
return ToString(format, null);
}
- public String ToString(String format, IFormatProvider provider)
+ public string ToString(string format, IFormatProvider provider)
{
if (m_value < 0 && format != null && format.Length > 0 && (format[0] == 'X' || format[0] == 'x'))
{
return Number.TryFormatInt32(m_value, format, provider, destination, out charsWritten);
}
- public static short Parse(String s)
+ public static short Parse(string s)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
}
- public static short Parse(String s, NumberStyles style)
+ public static short Parse(string s, NumberStyles style)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Parse((ReadOnlySpan<char>)s, style, NumberFormatInfo.CurrentInfo);
}
- public static short Parse(String s, IFormatProvider provider)
+ public static short Parse(string s, IFormatProvider provider)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
}
- public static short Parse(String s, NumberStyles style, IFormatProvider provider)
+ public static short Parse(string s, NumberStyles style, IFormatProvider provider)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
// for negative numbers
if ((style & NumberStyles.AllowHexSpecifier) != 0)
{ // We are parsing a hexadecimal number
- if ((i < 0) || (i > UInt16.MaxValue))
+ if ((i < 0) || (i > ushort.MaxValue))
{
throw new OverflowException(SR.Overflow_Int16);
}
return (short)i;
}
- public static bool TryParse(String s, out Int16 result)
+ public static bool TryParse(string s, out short result)
{
if (s == null)
{
return TryParse(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
}
- public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out Int16 result)
+ public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out short result)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
}
- private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out Int16 result)
+ private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out short result)
{
result = 0;
int i;
// for negative numbers
if ((style & NumberStyles.AllowHexSpecifier) != 0)
{ // We are parsing a hexadecimal number
- if ((i < 0) || i > UInt16.MaxValue)
+ if ((i < 0) || i > ushort.MaxValue)
{
return false;
}
- result = (Int16)i;
+ result = (short)i;
return true;
}
{
return false;
}
- result = (Int16)i;
+ result = (short)i;
return true;
}
return Convert.ToDouble(m_value);
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
return Convert.ToDecimal(m_value);
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Int16", "DateTime"));
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
[Serializable]
[StructLayout(LayoutKind.Sequential)]
[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public struct Int32 : IComparable, IConvertible, IFormattable, IComparable<Int32>, IEquatable<Int32>, ISpanFormattable
+ public struct Int32 : IComparable, IConvertible, IFormattable, IComparable<int>, IEquatable<int>, ISpanFormattable
{
private int m_value; // Do not rename (binary serialization)
// null is considered to be less than any instance, hence returns positive number
// If object is not of type Int32, this method throws an ArgumentException.
//
- public int CompareTo(Object value)
+ public int CompareTo(object value)
{
if (value == null)
{
return 1;
}
- if (value is Int32)
+ if (value is int)
{
// NOTE: Cannot use return (_value - value) as this causes a wrap
// around in cases where _value - value > MaxValue.
return 0;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
- if (!(obj is Int32))
+ if (!(obj is int))
{
return false;
}
- return m_value == ((Int32)obj).m_value;
+ return m_value == ((int)obj).m_value;
}
[NonVersionable]
- public bool Equals(Int32 obj)
+ public bool Equals(int obj)
{
return m_value == obj;
}
return m_value;
}
- public override String ToString()
+ public override string ToString()
{
return Number.FormatInt32(m_value, null, null);
}
- public String ToString(String format)
+ public string ToString(string format)
{
return Number.FormatInt32(m_value, format, null);
}
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
return Number.FormatInt32(m_value, null, provider);
}
- public String ToString(String format, IFormatProvider provider)
+ public string ToString(string format, IFormatProvider provider)
{
return Number.FormatInt32(m_value, format, provider);
}
return Number.TryFormatInt32(m_value, format, provider, destination, out charsWritten);
}
- public static int Parse(String s)
+ public static int Parse(string s)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseInt32(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
}
- public static int Parse(String s, NumberStyles style)
+ public static int Parse(string s, NumberStyles style)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
// a NumberFormatInfo isn't specified, the current culture's
// NumberFormatInfo is assumed.
//
- public static int Parse(String s, IFormatProvider provider)
+ public static int Parse(string s, IFormatProvider provider)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseInt32(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
// a NumberFormatInfo isn't specified, the current culture's
// NumberFormatInfo is assumed.
//
- public static int Parse(String s, NumberStyles style, IFormatProvider provider)
+ public static int Parse(string s, NumberStyles style, IFormatProvider provider)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
// Parses an integer from a String. Returns false rather
// than throwing exceptin if input is invalid
//
- public static bool TryParse(String s, out Int32 result)
+ public static bool TryParse(string s, out int result)
{
if (s == null)
{
// Parses an integer from a String in the given style. Returns false rather
// than throwing exceptin if input is invalid
//
- public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out Int32 result)
+ public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out int result)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
return Convert.ToDouble(m_value);
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
return Convert.ToDecimal(m_value);
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Int32", "DateTime"));
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
[Serializable]
[StructLayout(LayoutKind.Sequential)]
[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public struct Int64 : IComparable, IConvertible, IFormattable, IComparable<Int64>, IEquatable<Int64>, ISpanFormattable
+ public struct Int64 : IComparable, IConvertible, IFormattable, IComparable<long>, IEquatable<long>, ISpanFormattable
{
private long m_value; // Do not rename (binary serialization)
// null is considered to be less than any instance.
// If object is not of type Int64, this method throws an ArgumentException.
//
- public int CompareTo(Object value)
+ public int CompareTo(object value)
{
if (value == null)
{
return 1;
}
- if (value is Int64)
+ if (value is long)
{
// Need to use compare because subtraction will wrap
// to positive for very large neg numbers, etc.
throw new ArgumentException(SR.Arg_MustBeInt64);
}
- public int CompareTo(Int64 value)
+ public int CompareTo(long value)
{
// Need to use compare because subtraction will wrap
// to positive for very large neg numbers, etc.
return 0;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
- if (!(obj is Int64))
+ if (!(obj is long))
{
return false;
}
- return m_value == ((Int64)obj).m_value;
+ return m_value == ((long)obj).m_value;
}
[NonVersionable]
- public bool Equals(Int64 obj)
+ public bool Equals(long obj)
{
return m_value == obj;
}
return (unchecked((int)((long)m_value)) ^ (int)(m_value >> 32));
}
- public override String ToString()
+ public override string ToString()
{
return Number.FormatInt64(m_value, null, null);
}
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
return Number.FormatInt64(m_value, null, provider);
}
- public String ToString(String format)
+ public string ToString(string format)
{
return Number.FormatInt64(m_value, format, null);
}
- public String ToString(String format, IFormatProvider provider)
+ public string ToString(string format, IFormatProvider provider)
{
return Number.FormatInt64(m_value, format, provider);
}
return Number.TryFormatInt64(m_value, format, provider, destination, out charsWritten);
}
- public static long Parse(String s)
+ public static long Parse(string s)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
}
- public static long Parse(String s, NumberStyles style)
+ public static long Parse(string s, NumberStyles style)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseInt64(s, style, NumberFormatInfo.CurrentInfo);
}
- public static long Parse(String s, IFormatProvider provider)
+ public static long Parse(string s, IFormatProvider provider)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseInt64(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
// a NumberFormatInfo isn't specified, the current culture's
// NumberFormatInfo is assumed.
//
- public static long Parse(String s, NumberStyles style, IFormatProvider provider)
+ public static long Parse(string s, NumberStyles style, IFormatProvider provider)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseInt64(s, style, NumberFormatInfo.GetInstance(provider));
}
- public static Boolean TryParse(String s, out Int64 result)
+ public static bool TryParse(string s, out long result)
{
if (s == null)
{
return Number.TryParseInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo, out result);
}
- public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out Int64 result)
+ public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out long result)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
return Convert.ToDouble(m_value);
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
return Convert.ToDecimal(m_value);
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Int64", "DateTime"));
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
info.AddValue("value", ToInt64());
}
- public unsafe override bool Equals(Object obj)
+ public unsafe override bool Equals(object obj)
{
if (obj is IntPtr)
{
HResult = HResults.COR_E_INVALIDCAST;
}
- public InvalidCastException(String message)
+ public InvalidCastException(string message)
: base(message)
{
HResult = HResults.COR_E_INVALIDCAST;
}
- public InvalidCastException(String message, Exception innerException)
+ public InvalidCastException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_INVALIDCAST;
}
- public InvalidCastException(String message, int errorCode)
+ public InvalidCastException(string message, int errorCode)
: base(message)
{
HResult = errorCode;
HResult = HResults.COR_E_INVALIDOPERATION;
}
- public InvalidOperationException(String message)
+ public InvalidOperationException(string message)
: base(message)
{
HResult = HResults.COR_E_INVALIDOPERATION;
}
- public InvalidOperationException(String message, Exception innerException)
+ public InvalidOperationException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_INVALIDOPERATION;
HResult = HResults.COR_E_INVALIDPROGRAM;
}
- public InvalidProgramException(String message)
+ public InvalidProgramException(string message)
: base(message)
{
HResult = HResults.COR_E_INVALIDPROGRAM;
}
- public InvalidProgramException(String message, Exception inner)
+ public InvalidProgramException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_INVALIDPROGRAM;
{
}
- public InvalidTimeZoneException(String message)
+ public InvalidTimeZoneException(string message)
: base(message)
{
}
- public InvalidTimeZoneException(String message, Exception innerException)
+ public InvalidTimeZoneException(string message, Exception innerException)
: base(message, innerException)
{
}
// message, its HRESULT set to COR_E_ACCESS,
// and its ExceptionInfo reference set to null.
//
- public MemberAccessException(String message)
+ public MemberAccessException(string message)
: base(message)
{
HResult = HResults.COR_E_MEMBERACCESS;
}
- public MemberAccessException(String message, Exception inner)
+ public MemberAccessException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_MEMBERACCESS;
HResult = HResults.COR_E_METHODACCESS;
}
- public MethodAccessException(String message)
+ public MethodAccessException(string message)
: base(message)
{
HResult = HResults.COR_E_METHODACCESS;
}
- public MethodAccessException(String message, Exception inner)
+ public MethodAccessException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_METHODACCESS;
HResult = HResults.COR_E_MISSINGFIELD;
}
- public MissingFieldException(String message)
+ public MissingFieldException(string message)
: base(message)
{
HResult = HResults.COR_E_MISSINGFIELD;
}
- public MissingFieldException(String message, Exception inner)
+ public MissingFieldException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_MISSINGFIELD;
HResult = HResults.COR_E_MISSINGMEMBER;
}
- public MissingMemberException(String message)
+ public MissingMemberException(string message)
: base(message)
{
HResult = HResults.COR_E_MISSINGMEMBER;
}
- public MissingMemberException(String message, Exception inner)
+ public MissingMemberException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_MISSINGMEMBER;
HResult = HResults.COR_E_MULTICASTNOTSUPPORTED;
}
- public MulticastNotSupportedException(String message)
+ public MulticastNotSupportedException(string message)
: base(message)
{
HResult = HResults.COR_E_MULTICASTNOTSUPPORTED;
}
- public MulticastNotSupportedException(String message, Exception inner)
+ public MulticastNotSupportedException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_MULTICASTNOTSUPPORTED;
{
HResult = HResults.E_NOTIMPL;
}
- public NotImplementedException(String message)
+ public NotImplementedException(string message)
: base(message)
{
HResult = HResults.E_NOTIMPL;
}
- public NotImplementedException(String message, Exception inner)
+ public NotImplementedException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.E_NOTIMPL;
HResult = HResults.COR_E_NOTSUPPORTED;
}
- public NotSupportedException(String message)
+ public NotSupportedException(string message)
: base(message)
{
HResult = HResults.COR_E_NOTSUPPORTED;
}
- public NotSupportedException(String message, Exception innerException)
+ public NotSupportedException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_NOTSUPPORTED;
HResult = HResults.COR_E_NULLREFERENCE;
}
- public NullReferenceException(String message)
+ public NullReferenceException(string message)
: base(message)
{
HResult = HResults.COR_E_NULLREFERENCE;
}
- public NullReferenceException(String message, Exception innerException)
+ public NullReferenceException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_NULLREFERENCE;
{
// instantiated generic type only
Type genericType = nullableType.GetGenericTypeDefinition();
- if (Object.ReferenceEquals(genericType, typeof(Nullable<>)))
+ if (object.ReferenceEquals(genericType, typeof(Nullable<>)))
{
return nullableType.GetGenericArguments()[0];
}
internal class ConstantHelper
{
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Byte GetByteWithAllBitsSet()
+ public static byte GetByteWithAllBitsSet()
{
- Byte value = 0;
+ byte value = 0;
unsafe
{
unchecked
{
- *((Byte*)&value) = (Byte)0xff;
+ *((byte*)&value) = (byte)0xff;
}
}
return value;
}
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static SByte GetSByteWithAllBitsSet()
+ public static sbyte GetSByteWithAllBitsSet()
{
- SByte value = 0;
+ sbyte value = 0;
unsafe
{
unchecked
{
- *((SByte*)&value) = (SByte)0xff;
+ *((sbyte*)&value) = (sbyte)0xff;
}
}
return value;
}
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static UInt16 GetUInt16WithAllBitsSet()
+ public static ushort GetUInt16WithAllBitsSet()
{
- UInt16 value = 0;
+ ushort value = 0;
unsafe
{
unchecked
{
- *((UInt16*)&value) = (UInt16)0xffff;
+ *((ushort*)&value) = (ushort)0xffff;
}
}
return value;
}
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Int16 GetInt16WithAllBitsSet()
+ public static short GetInt16WithAllBitsSet()
{
- Int16 value = 0;
+ short value = 0;
unsafe
{
unchecked
{
- *((Int16*)&value) = (Int16)0xffff;
+ *((short*)&value) = (short)0xffff;
}
}
return value;
}
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static UInt32 GetUInt32WithAllBitsSet()
+ public static uint GetUInt32WithAllBitsSet()
{
- UInt32 value = 0;
+ uint value = 0;
unsafe
{
unchecked
{
- *((UInt32*)&value) = (UInt32)0xffffffff;
+ *((uint*)&value) = (uint)0xffffffff;
}
}
return value;
}
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Int32 GetInt32WithAllBitsSet()
+ public static int GetInt32WithAllBitsSet()
{
- Int32 value = 0;
+ int value = 0;
unsafe
{
unchecked
{
- *((Int32*)&value) = (Int32)0xffffffff;
+ *((int*)&value) = (int)0xffffffff;
}
}
return value;
}
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static UInt64 GetUInt64WithAllBitsSet()
+ public static ulong GetUInt64WithAllBitsSet()
{
- UInt64 value = 0;
+ ulong value = 0;
unsafe
{
unchecked
{
- *((UInt64*)&value) = (UInt64)0xffffffffffffffff;
+ *((ulong*)&value) = (ulong)0xffffffffffffffff;
}
}
return value;
}
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Int64 GetInt64WithAllBitsSet()
+ public static long GetInt64WithAllBitsSet()
{
- Int64 value = 0;
+ long value = 0;
unsafe
{
unchecked
{
- *((Int64*)&value) = (Int64)0xffffffffffffffff;
+ *((long*)&value) = (long)0xffffffffffffffff;
}
}
return value;
}
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Single GetSingleWithAllBitsSet()
+ public static float GetSingleWithAllBitsSet()
{
- Single value = 0;
+ float value = 0;
unsafe
{
unchecked
{
- *((Int32*)&value) = (Int32)0xffffffff;
+ *((int*)&value) = (int)0xffffffff;
}
}
return value;
}
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Double GetDoubleWithAllBitsSet()
+ public static double GetDoubleWithAllBitsSet()
{
- Double value = 0;
+ double value = 0;
unsafe
{
unchecked
{
- *((Int64*)&value) = (Int64)0xffffffffffffffff;
+ *((long*)&value) = (long)0xffffffffffffffff;
}
}
return value;
#region Internal Storage Fields
// Internal System.Byte Fields
[FieldOffset(0)]
- internal Byte byte_0;
+ internal byte byte_0;
[FieldOffset(1)]
- internal Byte byte_1;
+ internal byte byte_1;
[FieldOffset(2)]
- internal Byte byte_2;
+ internal byte byte_2;
[FieldOffset(3)]
- internal Byte byte_3;
+ internal byte byte_3;
[FieldOffset(4)]
- internal Byte byte_4;
+ internal byte byte_4;
[FieldOffset(5)]
- internal Byte byte_5;
+ internal byte byte_5;
[FieldOffset(6)]
- internal Byte byte_6;
+ internal byte byte_6;
[FieldOffset(7)]
- internal Byte byte_7;
+ internal byte byte_7;
[FieldOffset(8)]
- internal Byte byte_8;
+ internal byte byte_8;
[FieldOffset(9)]
- internal Byte byte_9;
+ internal byte byte_9;
[FieldOffset(10)]
- internal Byte byte_10;
+ internal byte byte_10;
[FieldOffset(11)]
- internal Byte byte_11;
+ internal byte byte_11;
[FieldOffset(12)]
- internal Byte byte_12;
+ internal byte byte_12;
[FieldOffset(13)]
- internal Byte byte_13;
+ internal byte byte_13;
[FieldOffset(14)]
- internal Byte byte_14;
+ internal byte byte_14;
[FieldOffset(15)]
- internal Byte byte_15;
+ internal byte byte_15;
// Internal System.SByte Fields
[FieldOffset(0)]
- internal SByte sbyte_0;
+ internal sbyte sbyte_0;
[FieldOffset(1)]
- internal SByte sbyte_1;
+ internal sbyte sbyte_1;
[FieldOffset(2)]
- internal SByte sbyte_2;
+ internal sbyte sbyte_2;
[FieldOffset(3)]
- internal SByte sbyte_3;
+ internal sbyte sbyte_3;
[FieldOffset(4)]
- internal SByte sbyte_4;
+ internal sbyte sbyte_4;
[FieldOffset(5)]
- internal SByte sbyte_5;
+ internal sbyte sbyte_5;
[FieldOffset(6)]
- internal SByte sbyte_6;
+ internal sbyte sbyte_6;
[FieldOffset(7)]
- internal SByte sbyte_7;
+ internal sbyte sbyte_7;
[FieldOffset(8)]
- internal SByte sbyte_8;
+ internal sbyte sbyte_8;
[FieldOffset(9)]
- internal SByte sbyte_9;
+ internal sbyte sbyte_9;
[FieldOffset(10)]
- internal SByte sbyte_10;
+ internal sbyte sbyte_10;
[FieldOffset(11)]
- internal SByte sbyte_11;
+ internal sbyte sbyte_11;
[FieldOffset(12)]
- internal SByte sbyte_12;
+ internal sbyte sbyte_12;
[FieldOffset(13)]
- internal SByte sbyte_13;
+ internal sbyte sbyte_13;
[FieldOffset(14)]
- internal SByte sbyte_14;
+ internal sbyte sbyte_14;
[FieldOffset(15)]
- internal SByte sbyte_15;
+ internal sbyte sbyte_15;
// Internal System.UInt16 Fields
[FieldOffset(0)]
- internal UInt16 uint16_0;
+ internal ushort uint16_0;
[FieldOffset(2)]
- internal UInt16 uint16_1;
+ internal ushort uint16_1;
[FieldOffset(4)]
- internal UInt16 uint16_2;
+ internal ushort uint16_2;
[FieldOffset(6)]
- internal UInt16 uint16_3;
+ internal ushort uint16_3;
[FieldOffset(8)]
- internal UInt16 uint16_4;
+ internal ushort uint16_4;
[FieldOffset(10)]
- internal UInt16 uint16_5;
+ internal ushort uint16_5;
[FieldOffset(12)]
- internal UInt16 uint16_6;
+ internal ushort uint16_6;
[FieldOffset(14)]
- internal UInt16 uint16_7;
+ internal ushort uint16_7;
// Internal System.Int16 Fields
[FieldOffset(0)]
- internal Int16 int16_0;
+ internal short int16_0;
[FieldOffset(2)]
- internal Int16 int16_1;
+ internal short int16_1;
[FieldOffset(4)]
- internal Int16 int16_2;
+ internal short int16_2;
[FieldOffset(6)]
- internal Int16 int16_3;
+ internal short int16_3;
[FieldOffset(8)]
- internal Int16 int16_4;
+ internal short int16_4;
[FieldOffset(10)]
- internal Int16 int16_5;
+ internal short int16_5;
[FieldOffset(12)]
- internal Int16 int16_6;
+ internal short int16_6;
[FieldOffset(14)]
- internal Int16 int16_7;
+ internal short int16_7;
// Internal System.UInt32 Fields
[FieldOffset(0)]
- internal UInt32 uint32_0;
+ internal uint uint32_0;
[FieldOffset(4)]
- internal UInt32 uint32_1;
+ internal uint uint32_1;
[FieldOffset(8)]
- internal UInt32 uint32_2;
+ internal uint uint32_2;
[FieldOffset(12)]
- internal UInt32 uint32_3;
+ internal uint uint32_3;
// Internal System.Int32 Fields
[FieldOffset(0)]
- internal Int32 int32_0;
+ internal int int32_0;
[FieldOffset(4)]
- internal Int32 int32_1;
+ internal int int32_1;
[FieldOffset(8)]
- internal Int32 int32_2;
+ internal int int32_2;
[FieldOffset(12)]
- internal Int32 int32_3;
+ internal int int32_3;
// Internal System.UInt64 Fields
[FieldOffset(0)]
- internal UInt64 uint64_0;
+ internal ulong uint64_0;
[FieldOffset(8)]
- internal UInt64 uint64_1;
+ internal ulong uint64_1;
// Internal System.Int64 Fields
[FieldOffset(0)]
- internal Int64 int64_0;
+ internal long int64_0;
[FieldOffset(8)]
- internal Int64 int64_1;
+ internal long int64_1;
// Internal System.Single Fields
[FieldOffset(0)]
- internal Single single_0;
+ internal float single_0;
[FieldOffset(4)]
- internal Single single_1;
+ internal float single_1;
[FieldOffset(8)]
- internal Single single_2;
+ internal float single_2;
[FieldOffset(12)]
- internal Single single_3;
+ internal float single_3;
// Internal System.Double Fields
[FieldOffset(0)]
- internal Double double_0;
+ internal double double_0;
[FieldOffset(8)]
- internal Double double_1;
+ internal double double_1;
#endregion Internal Storage Fields
}
int vectorSizeInBytes = (int)(byteBase - vectorBase);
int typeSizeInBytes = -1;
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- typeSizeInBytes = sizeof(Byte);
+ typeSizeInBytes = sizeof(byte);
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- typeSizeInBytes = sizeof(SByte);
+ typeSizeInBytes = sizeof(sbyte);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- typeSizeInBytes = sizeof(UInt16);
+ typeSizeInBytes = sizeof(ushort);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- typeSizeInBytes = sizeof(Int16);
+ typeSizeInBytes = sizeof(short);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- typeSizeInBytes = sizeof(UInt32);
+ typeSizeInBytes = sizeof(uint);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- typeSizeInBytes = sizeof(Int32);
+ typeSizeInBytes = sizeof(int);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- typeSizeInBytes = sizeof(UInt64);
+ typeSizeInBytes = sizeof(ulong);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- typeSizeInBytes = sizeof(Int64);
+ typeSizeInBytes = sizeof(long);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- typeSizeInBytes = sizeof(Single);
+ typeSizeInBytes = sizeof(float);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- typeSizeInBytes = sizeof(Double);
+ typeSizeInBytes = sizeof(double);
}
else
{
{
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- fixed (Byte* basePtr = &this.register.byte_0)
+ fixed (byte* basePtr = &this.register.byte_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (Byte)(object)value;
+ *(basePtr + g) = (byte)(object)value;
}
}
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- fixed (SByte* basePtr = &this.register.sbyte_0)
+ fixed (sbyte* basePtr = &this.register.sbyte_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (SByte)(object)value;
+ *(basePtr + g) = (sbyte)(object)value;
}
}
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- fixed (UInt16* basePtr = &this.register.uint16_0)
+ fixed (ushort* basePtr = &this.register.uint16_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (UInt16)(object)value;
+ *(basePtr + g) = (ushort)(object)value;
}
}
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- fixed (Int16* basePtr = &this.register.int16_0)
+ fixed (short* basePtr = &this.register.int16_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (Int16)(object)value;
+ *(basePtr + g) = (short)(object)value;
}
}
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- fixed (UInt32* basePtr = &this.register.uint32_0)
+ fixed (uint* basePtr = &this.register.uint32_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (UInt32)(object)value;
+ *(basePtr + g) = (uint)(object)value;
}
}
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- fixed (Int32* basePtr = &this.register.int32_0)
+ fixed (int* basePtr = &this.register.int32_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (Int32)(object)value;
+ *(basePtr + g) = (int)(object)value;
}
}
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- fixed (UInt64* basePtr = &this.register.uint64_0)
+ fixed (ulong* basePtr = &this.register.uint64_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (UInt64)(object)value;
+ *(basePtr + g) = (ulong)(object)value;
}
}
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- fixed (Int64* basePtr = &this.register.int64_0)
+ fixed (long* basePtr = &this.register.int64_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (Int64)(object)value;
+ *(basePtr + g) = (long)(object)value;
}
}
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- fixed (Single* basePtr = &this.register.single_0)
+ fixed (float* basePtr = &this.register.single_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (Single)(object)value;
+ *(basePtr + g) = (float)(object)value;
}
}
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- fixed (Double* basePtr = &this.register.double_0)
+ fixed (double* basePtr = &this.register.double_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (Double)(object)value;
+ *(basePtr + g) = (double)(object)value;
}
}
}
}
else
{
- if (typeof(T) == typeof(Byte))
- {
- register.byte_0 = (Byte)(object)value;
- register.byte_1 = (Byte)(object)value;
- register.byte_2 = (Byte)(object)value;
- register.byte_3 = (Byte)(object)value;
- register.byte_4 = (Byte)(object)value;
- register.byte_5 = (Byte)(object)value;
- register.byte_6 = (Byte)(object)value;
- register.byte_7 = (Byte)(object)value;
- register.byte_8 = (Byte)(object)value;
- register.byte_9 = (Byte)(object)value;
- register.byte_10 = (Byte)(object)value;
- register.byte_11 = (Byte)(object)value;
- register.byte_12 = (Byte)(object)value;
- register.byte_13 = (Byte)(object)value;
- register.byte_14 = (Byte)(object)value;
- register.byte_15 = (Byte)(object)value;
- }
- else if (typeof(T) == typeof(SByte))
- {
- register.sbyte_0 = (SByte)(object)value;
- register.sbyte_1 = (SByte)(object)value;
- register.sbyte_2 = (SByte)(object)value;
- register.sbyte_3 = (SByte)(object)value;
- register.sbyte_4 = (SByte)(object)value;
- register.sbyte_5 = (SByte)(object)value;
- register.sbyte_6 = (SByte)(object)value;
- register.sbyte_7 = (SByte)(object)value;
- register.sbyte_8 = (SByte)(object)value;
- register.sbyte_9 = (SByte)(object)value;
- register.sbyte_10 = (SByte)(object)value;
- register.sbyte_11 = (SByte)(object)value;
- register.sbyte_12 = (SByte)(object)value;
- register.sbyte_13 = (SByte)(object)value;
- register.sbyte_14 = (SByte)(object)value;
- register.sbyte_15 = (SByte)(object)value;
- }
- else if (typeof(T) == typeof(UInt16))
- {
- register.uint16_0 = (UInt16)(object)value;
- register.uint16_1 = (UInt16)(object)value;
- register.uint16_2 = (UInt16)(object)value;
- register.uint16_3 = (UInt16)(object)value;
- register.uint16_4 = (UInt16)(object)value;
- register.uint16_5 = (UInt16)(object)value;
- register.uint16_6 = (UInt16)(object)value;
- register.uint16_7 = (UInt16)(object)value;
- }
- else if (typeof(T) == typeof(Int16))
- {
- register.int16_0 = (Int16)(object)value;
- register.int16_1 = (Int16)(object)value;
- register.int16_2 = (Int16)(object)value;
- register.int16_3 = (Int16)(object)value;
- register.int16_4 = (Int16)(object)value;
- register.int16_5 = (Int16)(object)value;
- register.int16_6 = (Int16)(object)value;
- register.int16_7 = (Int16)(object)value;
- }
- else if (typeof(T) == typeof(UInt32))
- {
- register.uint32_0 = (UInt32)(object)value;
- register.uint32_1 = (UInt32)(object)value;
- register.uint32_2 = (UInt32)(object)value;
- register.uint32_3 = (UInt32)(object)value;
- }
- else if (typeof(T) == typeof(Int32))
- {
- register.int32_0 = (Int32)(object)value;
- register.int32_1 = (Int32)(object)value;
- register.int32_2 = (Int32)(object)value;
- register.int32_3 = (Int32)(object)value;
- }
- else if (typeof(T) == typeof(UInt64))
- {
- register.uint64_0 = (UInt64)(object)value;
- register.uint64_1 = (UInt64)(object)value;
- }
- else if (typeof(T) == typeof(Int64))
- {
- register.int64_0 = (Int64)(object)value;
- register.int64_1 = (Int64)(object)value;
- }
- else if (typeof(T) == typeof(Single))
- {
- register.single_0 = (Single)(object)value;
- register.single_1 = (Single)(object)value;
- register.single_2 = (Single)(object)value;
- register.single_3 = (Single)(object)value;
- }
- else if (typeof(T) == typeof(Double))
- {
- register.double_0 = (Double)(object)value;
- register.double_1 = (Double)(object)value;
+ if (typeof(T) == typeof(byte))
+ {
+ register.byte_0 = (byte)(object)value;
+ register.byte_1 = (byte)(object)value;
+ register.byte_2 = (byte)(object)value;
+ register.byte_3 = (byte)(object)value;
+ register.byte_4 = (byte)(object)value;
+ register.byte_5 = (byte)(object)value;
+ register.byte_6 = (byte)(object)value;
+ register.byte_7 = (byte)(object)value;
+ register.byte_8 = (byte)(object)value;
+ register.byte_9 = (byte)(object)value;
+ register.byte_10 = (byte)(object)value;
+ register.byte_11 = (byte)(object)value;
+ register.byte_12 = (byte)(object)value;
+ register.byte_13 = (byte)(object)value;
+ register.byte_14 = (byte)(object)value;
+ register.byte_15 = (byte)(object)value;
+ }
+ else if (typeof(T) == typeof(sbyte))
+ {
+ register.sbyte_0 = (sbyte)(object)value;
+ register.sbyte_1 = (sbyte)(object)value;
+ register.sbyte_2 = (sbyte)(object)value;
+ register.sbyte_3 = (sbyte)(object)value;
+ register.sbyte_4 = (sbyte)(object)value;
+ register.sbyte_5 = (sbyte)(object)value;
+ register.sbyte_6 = (sbyte)(object)value;
+ register.sbyte_7 = (sbyte)(object)value;
+ register.sbyte_8 = (sbyte)(object)value;
+ register.sbyte_9 = (sbyte)(object)value;
+ register.sbyte_10 = (sbyte)(object)value;
+ register.sbyte_11 = (sbyte)(object)value;
+ register.sbyte_12 = (sbyte)(object)value;
+ register.sbyte_13 = (sbyte)(object)value;
+ register.sbyte_14 = (sbyte)(object)value;
+ register.sbyte_15 = (sbyte)(object)value;
+ }
+ else if (typeof(T) == typeof(ushort))
+ {
+ register.uint16_0 = (ushort)(object)value;
+ register.uint16_1 = (ushort)(object)value;
+ register.uint16_2 = (ushort)(object)value;
+ register.uint16_3 = (ushort)(object)value;
+ register.uint16_4 = (ushort)(object)value;
+ register.uint16_5 = (ushort)(object)value;
+ register.uint16_6 = (ushort)(object)value;
+ register.uint16_7 = (ushort)(object)value;
+ }
+ else if (typeof(T) == typeof(short))
+ {
+ register.int16_0 = (short)(object)value;
+ register.int16_1 = (short)(object)value;
+ register.int16_2 = (short)(object)value;
+ register.int16_3 = (short)(object)value;
+ register.int16_4 = (short)(object)value;
+ register.int16_5 = (short)(object)value;
+ register.int16_6 = (short)(object)value;
+ register.int16_7 = (short)(object)value;
+ }
+ else if (typeof(T) == typeof(uint))
+ {
+ register.uint32_0 = (uint)(object)value;
+ register.uint32_1 = (uint)(object)value;
+ register.uint32_2 = (uint)(object)value;
+ register.uint32_3 = (uint)(object)value;
+ }
+ else if (typeof(T) == typeof(int))
+ {
+ register.int32_0 = (int)(object)value;
+ register.int32_1 = (int)(object)value;
+ register.int32_2 = (int)(object)value;
+ register.int32_3 = (int)(object)value;
+ }
+ else if (typeof(T) == typeof(ulong))
+ {
+ register.uint64_0 = (ulong)(object)value;
+ register.uint64_1 = (ulong)(object)value;
+ }
+ else if (typeof(T) == typeof(long))
+ {
+ register.int64_0 = (long)(object)value;
+ register.int64_1 = (long)(object)value;
+ }
+ else if (typeof(T) == typeof(float))
+ {
+ register.single_0 = (float)(object)value;
+ register.single_1 = (float)(object)value;
+ register.single_2 = (float)(object)value;
+ register.single_3 = (float)(object)value;
+ }
+ else if (typeof(T) == typeof(double))
+ {
+ register.double_0 = (double)(object)value;
+ register.double_1 = (double)(object)value;
}
}
}
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- fixed (Byte* basePtr = &this.register.byte_0)
+ fixed (byte* basePtr = &this.register.byte_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (Byte)(object)values[g + index];
+ *(basePtr + g) = (byte)(object)values[g + index];
}
}
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- fixed (SByte* basePtr = &this.register.sbyte_0)
+ fixed (sbyte* basePtr = &this.register.sbyte_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (SByte)(object)values[g + index];
+ *(basePtr + g) = (sbyte)(object)values[g + index];
}
}
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- fixed (UInt16* basePtr = &this.register.uint16_0)
+ fixed (ushort* basePtr = &this.register.uint16_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (UInt16)(object)values[g + index];
+ *(basePtr + g) = (ushort)(object)values[g + index];
}
}
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- fixed (Int16* basePtr = &this.register.int16_0)
+ fixed (short* basePtr = &this.register.int16_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (Int16)(object)values[g + index];
+ *(basePtr + g) = (short)(object)values[g + index];
}
}
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- fixed (UInt32* basePtr = &this.register.uint32_0)
+ fixed (uint* basePtr = &this.register.uint32_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (UInt32)(object)values[g + index];
+ *(basePtr + g) = (uint)(object)values[g + index];
}
}
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- fixed (Int32* basePtr = &this.register.int32_0)
+ fixed (int* basePtr = &this.register.int32_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (Int32)(object)values[g + index];
+ *(basePtr + g) = (int)(object)values[g + index];
}
}
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- fixed (UInt64* basePtr = &this.register.uint64_0)
+ fixed (ulong* basePtr = &this.register.uint64_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (UInt64)(object)values[g + index];
+ *(basePtr + g) = (ulong)(object)values[g + index];
}
}
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- fixed (Int64* basePtr = &this.register.int64_0)
+ fixed (long* basePtr = &this.register.int64_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (Int64)(object)values[g + index];
+ *(basePtr + g) = (long)(object)values[g + index];
}
}
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- fixed (Single* basePtr = &this.register.single_0)
+ fixed (float* basePtr = &this.register.single_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (Single)(object)values[g + index];
+ *(basePtr + g) = (float)(object)values[g + index];
}
}
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- fixed (Double* basePtr = &this.register.double_0)
+ fixed (double* basePtr = &this.register.double_0)
{
for (int g = 0; g < Count; g++)
{
- *(basePtr + g) = (Double)(object)values[g + index];
+ *(basePtr + g) = (double)(object)values[g + index];
}
}
}
}
else
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- fixed (Byte* basePtr = &this.register.byte_0)
+ fixed (byte* basePtr = &this.register.byte_0)
{
- *(basePtr + 0) = (Byte)(object)values[0 + index];
- *(basePtr + 1) = (Byte)(object)values[1 + index];
- *(basePtr + 2) = (Byte)(object)values[2 + index];
- *(basePtr + 3) = (Byte)(object)values[3 + index];
- *(basePtr + 4) = (Byte)(object)values[4 + index];
- *(basePtr + 5) = (Byte)(object)values[5 + index];
- *(basePtr + 6) = (Byte)(object)values[6 + index];
- *(basePtr + 7) = (Byte)(object)values[7 + index];
- *(basePtr + 8) = (Byte)(object)values[8 + index];
- *(basePtr + 9) = (Byte)(object)values[9 + index];
- *(basePtr + 10) = (Byte)(object)values[10 + index];
- *(basePtr + 11) = (Byte)(object)values[11 + index];
- *(basePtr + 12) = (Byte)(object)values[12 + index];
- *(basePtr + 13) = (Byte)(object)values[13 + index];
- *(basePtr + 14) = (Byte)(object)values[14 + index];
- *(basePtr + 15) = (Byte)(object)values[15 + index];
+ *(basePtr + 0) = (byte)(object)values[0 + index];
+ *(basePtr + 1) = (byte)(object)values[1 + index];
+ *(basePtr + 2) = (byte)(object)values[2 + index];
+ *(basePtr + 3) = (byte)(object)values[3 + index];
+ *(basePtr + 4) = (byte)(object)values[4 + index];
+ *(basePtr + 5) = (byte)(object)values[5 + index];
+ *(basePtr + 6) = (byte)(object)values[6 + index];
+ *(basePtr + 7) = (byte)(object)values[7 + index];
+ *(basePtr + 8) = (byte)(object)values[8 + index];
+ *(basePtr + 9) = (byte)(object)values[9 + index];
+ *(basePtr + 10) = (byte)(object)values[10 + index];
+ *(basePtr + 11) = (byte)(object)values[11 + index];
+ *(basePtr + 12) = (byte)(object)values[12 + index];
+ *(basePtr + 13) = (byte)(object)values[13 + index];
+ *(basePtr + 14) = (byte)(object)values[14 + index];
+ *(basePtr + 15) = (byte)(object)values[15 + index];
}
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- fixed (SByte* basePtr = &this.register.sbyte_0)
+ fixed (sbyte* basePtr = &this.register.sbyte_0)
{
- *(basePtr + 0) = (SByte)(object)values[0 + index];
- *(basePtr + 1) = (SByte)(object)values[1 + index];
- *(basePtr + 2) = (SByte)(object)values[2 + index];
- *(basePtr + 3) = (SByte)(object)values[3 + index];
- *(basePtr + 4) = (SByte)(object)values[4 + index];
- *(basePtr + 5) = (SByte)(object)values[5 + index];
- *(basePtr + 6) = (SByte)(object)values[6 + index];
- *(basePtr + 7) = (SByte)(object)values[7 + index];
- *(basePtr + 8) = (SByte)(object)values[8 + index];
- *(basePtr + 9) = (SByte)(object)values[9 + index];
- *(basePtr + 10) = (SByte)(object)values[10 + index];
- *(basePtr + 11) = (SByte)(object)values[11 + index];
- *(basePtr + 12) = (SByte)(object)values[12 + index];
- *(basePtr + 13) = (SByte)(object)values[13 + index];
- *(basePtr + 14) = (SByte)(object)values[14 + index];
- *(basePtr + 15) = (SByte)(object)values[15 + index];
+ *(basePtr + 0) = (sbyte)(object)values[0 + index];
+ *(basePtr + 1) = (sbyte)(object)values[1 + index];
+ *(basePtr + 2) = (sbyte)(object)values[2 + index];
+ *(basePtr + 3) = (sbyte)(object)values[3 + index];
+ *(basePtr + 4) = (sbyte)(object)values[4 + index];
+ *(basePtr + 5) = (sbyte)(object)values[5 + index];
+ *(basePtr + 6) = (sbyte)(object)values[6 + index];
+ *(basePtr + 7) = (sbyte)(object)values[7 + index];
+ *(basePtr + 8) = (sbyte)(object)values[8 + index];
+ *(basePtr + 9) = (sbyte)(object)values[9 + index];
+ *(basePtr + 10) = (sbyte)(object)values[10 + index];
+ *(basePtr + 11) = (sbyte)(object)values[11 + index];
+ *(basePtr + 12) = (sbyte)(object)values[12 + index];
+ *(basePtr + 13) = (sbyte)(object)values[13 + index];
+ *(basePtr + 14) = (sbyte)(object)values[14 + index];
+ *(basePtr + 15) = (sbyte)(object)values[15 + index];
}
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- fixed (UInt16* basePtr = &this.register.uint16_0)
+ fixed (ushort* basePtr = &this.register.uint16_0)
{
- *(basePtr + 0) = (UInt16)(object)values[0 + index];
- *(basePtr + 1) = (UInt16)(object)values[1 + index];
- *(basePtr + 2) = (UInt16)(object)values[2 + index];
- *(basePtr + 3) = (UInt16)(object)values[3 + index];
- *(basePtr + 4) = (UInt16)(object)values[4 + index];
- *(basePtr + 5) = (UInt16)(object)values[5 + index];
- *(basePtr + 6) = (UInt16)(object)values[6 + index];
- *(basePtr + 7) = (UInt16)(object)values[7 + index];
+ *(basePtr + 0) = (ushort)(object)values[0 + index];
+ *(basePtr + 1) = (ushort)(object)values[1 + index];
+ *(basePtr + 2) = (ushort)(object)values[2 + index];
+ *(basePtr + 3) = (ushort)(object)values[3 + index];
+ *(basePtr + 4) = (ushort)(object)values[4 + index];
+ *(basePtr + 5) = (ushort)(object)values[5 + index];
+ *(basePtr + 6) = (ushort)(object)values[6 + index];
+ *(basePtr + 7) = (ushort)(object)values[7 + index];
}
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- fixed (Int16* basePtr = &this.register.int16_0)
+ fixed (short* basePtr = &this.register.int16_0)
{
- *(basePtr + 0) = (Int16)(object)values[0 + index];
- *(basePtr + 1) = (Int16)(object)values[1 + index];
- *(basePtr + 2) = (Int16)(object)values[2 + index];
- *(basePtr + 3) = (Int16)(object)values[3 + index];
- *(basePtr + 4) = (Int16)(object)values[4 + index];
- *(basePtr + 5) = (Int16)(object)values[5 + index];
- *(basePtr + 6) = (Int16)(object)values[6 + index];
- *(basePtr + 7) = (Int16)(object)values[7 + index];
+ *(basePtr + 0) = (short)(object)values[0 + index];
+ *(basePtr + 1) = (short)(object)values[1 + index];
+ *(basePtr + 2) = (short)(object)values[2 + index];
+ *(basePtr + 3) = (short)(object)values[3 + index];
+ *(basePtr + 4) = (short)(object)values[4 + index];
+ *(basePtr + 5) = (short)(object)values[5 + index];
+ *(basePtr + 6) = (short)(object)values[6 + index];
+ *(basePtr + 7) = (short)(object)values[7 + index];
}
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- fixed (UInt32* basePtr = &this.register.uint32_0)
+ fixed (uint* basePtr = &this.register.uint32_0)
{
- *(basePtr + 0) = (UInt32)(object)values[0 + index];
- *(basePtr + 1) = (UInt32)(object)values[1 + index];
- *(basePtr + 2) = (UInt32)(object)values[2 + index];
- *(basePtr + 3) = (UInt32)(object)values[3 + index];
+ *(basePtr + 0) = (uint)(object)values[0 + index];
+ *(basePtr + 1) = (uint)(object)values[1 + index];
+ *(basePtr + 2) = (uint)(object)values[2 + index];
+ *(basePtr + 3) = (uint)(object)values[3 + index];
}
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- fixed (Int32* basePtr = &this.register.int32_0)
+ fixed (int* basePtr = &this.register.int32_0)
{
- *(basePtr + 0) = (Int32)(object)values[0 + index];
- *(basePtr + 1) = (Int32)(object)values[1 + index];
- *(basePtr + 2) = (Int32)(object)values[2 + index];
- *(basePtr + 3) = (Int32)(object)values[3 + index];
+ *(basePtr + 0) = (int)(object)values[0 + index];
+ *(basePtr + 1) = (int)(object)values[1 + index];
+ *(basePtr + 2) = (int)(object)values[2 + index];
+ *(basePtr + 3) = (int)(object)values[3 + index];
}
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- fixed (UInt64* basePtr = &this.register.uint64_0)
+ fixed (ulong* basePtr = &this.register.uint64_0)
{
- *(basePtr + 0) = (UInt64)(object)values[0 + index];
- *(basePtr + 1) = (UInt64)(object)values[1 + index];
+ *(basePtr + 0) = (ulong)(object)values[0 + index];
+ *(basePtr + 1) = (ulong)(object)values[1 + index];
}
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- fixed (Int64* basePtr = &this.register.int64_0)
+ fixed (long* basePtr = &this.register.int64_0)
{
- *(basePtr + 0) = (Int64)(object)values[0 + index];
- *(basePtr + 1) = (Int64)(object)values[1 + index];
+ *(basePtr + 0) = (long)(object)values[0 + index];
+ *(basePtr + 1) = (long)(object)values[1 + index];
}
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- fixed (Single* basePtr = &this.register.single_0)
+ fixed (float* basePtr = &this.register.single_0)
{
- *(basePtr + 0) = (Single)(object)values[0 + index];
- *(basePtr + 1) = (Single)(object)values[1 + index];
- *(basePtr + 2) = (Single)(object)values[2 + index];
- *(basePtr + 3) = (Single)(object)values[3 + index];
+ *(basePtr + 0) = (float)(object)values[0 + index];
+ *(basePtr + 1) = (float)(object)values[1 + index];
+ *(basePtr + 2) = (float)(object)values[2 + index];
+ *(basePtr + 3) = (float)(object)values[3 + index];
}
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- fixed (Double* basePtr = &this.register.double_0)
+ fixed (double* basePtr = &this.register.double_0)
{
- *(basePtr + 0) = (Double)(object)values[0 + index];
- *(basePtr + 1) = (Double)(object)values[1 + index];
+ *(basePtr + 0) = (double)(object)values[0 + index];
+ *(basePtr + 1) = (double)(object)values[1 + index];
}
}
}
internal unsafe Vector(void* dataPointer, int offset)
: this()
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- Byte* castedPtr = (Byte*)dataPointer;
+ byte* castedPtr = (byte*)dataPointer;
castedPtr += offset;
- fixed (Byte* registerBase = &this.register.byte_0)
+ fixed (byte* registerBase = &this.register.byte_0)
{
for (int g = 0; g < Count; g++)
{
}
}
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- SByte* castedPtr = (SByte*)dataPointer;
+ sbyte* castedPtr = (sbyte*)dataPointer;
castedPtr += offset;
- fixed (SByte* registerBase = &this.register.sbyte_0)
+ fixed (sbyte* registerBase = &this.register.sbyte_0)
{
for (int g = 0; g < Count; g++)
{
}
}
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- UInt16* castedPtr = (UInt16*)dataPointer;
+ ushort* castedPtr = (ushort*)dataPointer;
castedPtr += offset;
- fixed (UInt16* registerBase = &this.register.uint16_0)
+ fixed (ushort* registerBase = &this.register.uint16_0)
{
for (int g = 0; g < Count; g++)
{
}
}
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16* castedPtr = (Int16*)dataPointer;
+ short* castedPtr = (short*)dataPointer;
castedPtr += offset;
- fixed (Int16* registerBase = &this.register.int16_0)
+ fixed (short* registerBase = &this.register.int16_0)
{
for (int g = 0; g < Count; g++)
{
}
}
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32* castedPtr = (UInt32*)dataPointer;
+ uint* castedPtr = (uint*)dataPointer;
castedPtr += offset;
- fixed (UInt32* registerBase = &this.register.uint32_0)
+ fixed (uint* registerBase = &this.register.uint32_0)
{
for (int g = 0; g < Count; g++)
{
}
}
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32* castedPtr = (Int32*)dataPointer;
+ int* castedPtr = (int*)dataPointer;
castedPtr += offset;
- fixed (Int32* registerBase = &this.register.int32_0)
+ fixed (int* registerBase = &this.register.int32_0)
{
for (int g = 0; g < Count; g++)
{
}
}
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64* castedPtr = (UInt64*)dataPointer;
+ ulong* castedPtr = (ulong*)dataPointer;
castedPtr += offset;
- fixed (UInt64* registerBase = &this.register.uint64_0)
+ fixed (ulong* registerBase = &this.register.uint64_0)
{
for (int g = 0; g < Count; g++)
{
}
}
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64* castedPtr = (Int64*)dataPointer;
+ long* castedPtr = (long*)dataPointer;
castedPtr += offset;
- fixed (Int64* registerBase = &this.register.int64_0)
+ fixed (long* registerBase = &this.register.int64_0)
{
for (int g = 0; g < Count; g++)
{
}
}
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single* castedPtr = (Single*)dataPointer;
+ float* castedPtr = (float*)dataPointer;
castedPtr += offset;
- fixed (Single* registerBase = &this.register.single_0)
+ fixed (float* registerBase = &this.register.single_0)
{
for (int g = 0; g < Count; g++)
{
}
}
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double* castedPtr = (Double*)dataPointer;
+ double* castedPtr = (double*)dataPointer;
castedPtr += offset;
- fixed (Double* registerBase = &this.register.double_0)
+ fixed (double* registerBase = &this.register.double_0)
{
for (int g = 0; g < Count; g++)
{
public Vector(Span<T> values)
: this()
{
- if ((typeof(T) == typeof(Byte))
- || (typeof(T) == typeof(SByte))
- || (typeof(T) == typeof(UInt16))
- || (typeof(T) == typeof(Int16))
- || (typeof(T) == typeof(UInt32))
- || (typeof(T) == typeof(Int32))
- || (typeof(T) == typeof(UInt64))
- || (typeof(T) == typeof(Int64))
- || (typeof(T) == typeof(Single))
- || (typeof(T) == typeof(Double)))
+ if ((typeof(T) == typeof(byte))
+ || (typeof(T) == typeof(sbyte))
+ || (typeof(T) == typeof(ushort))
+ || (typeof(T) == typeof(short))
+ || (typeof(T) == typeof(uint))
+ || (typeof(T) == typeof(int))
+ || (typeof(T) == typeof(ulong))
+ || (typeof(T) == typeof(long))
+ || (typeof(T) == typeof(float))
+ || (typeof(T) == typeof(double)))
{
if (values.Length < Count)
{
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- Byte[] byteArray = (Byte[])(object)destination;
- fixed (Byte* destinationBase = byteArray)
+ byte[] byteArray = (byte[])(object)destination;
+ fixed (byte* destinationBase = byteArray)
{
for (int g = 0; g < Count; g++)
{
- destinationBase[startIndex + g] = (Byte)(object)this[g];
+ destinationBase[startIndex + g] = (byte)(object)this[g];
}
}
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- SByte[] sbyteArray = (SByte[])(object)destination;
- fixed (SByte* destinationBase = sbyteArray)
+ sbyte[] sbyteArray = (sbyte[])(object)destination;
+ fixed (sbyte* destinationBase = sbyteArray)
{
for (int g = 0; g < Count; g++)
{
- destinationBase[startIndex + g] = (SByte)(object)this[g];
+ destinationBase[startIndex + g] = (sbyte)(object)this[g];
}
}
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- UInt16[] uint16Array = (UInt16[])(object)destination;
- fixed (UInt16* destinationBase = uint16Array)
+ ushort[] uint16Array = (ushort[])(object)destination;
+ fixed (ushort* destinationBase = uint16Array)
{
for (int g = 0; g < Count; g++)
{
- destinationBase[startIndex + g] = (UInt16)(object)this[g];
+ destinationBase[startIndex + g] = (ushort)(object)this[g];
}
}
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16[] int16Array = (Int16[])(object)destination;
- fixed (Int16* destinationBase = int16Array)
+ short[] int16Array = (short[])(object)destination;
+ fixed (short* destinationBase = int16Array)
{
for (int g = 0; g < Count; g++)
{
- destinationBase[startIndex + g] = (Int16)(object)this[g];
+ destinationBase[startIndex + g] = (short)(object)this[g];
}
}
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32[] uint32Array = (UInt32[])(object)destination;
- fixed (UInt32* destinationBase = uint32Array)
+ uint[] uint32Array = (uint[])(object)destination;
+ fixed (uint* destinationBase = uint32Array)
{
for (int g = 0; g < Count; g++)
{
- destinationBase[startIndex + g] = (UInt32)(object)this[g];
+ destinationBase[startIndex + g] = (uint)(object)this[g];
}
}
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32[] int32Array = (Int32[])(object)destination;
- fixed (Int32* destinationBase = int32Array)
+ int[] int32Array = (int[])(object)destination;
+ fixed (int* destinationBase = int32Array)
{
for (int g = 0; g < Count; g++)
{
- destinationBase[startIndex + g] = (Int32)(object)this[g];
+ destinationBase[startIndex + g] = (int)(object)this[g];
}
}
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64[] uint64Array = (UInt64[])(object)destination;
- fixed (UInt64* destinationBase = uint64Array)
+ ulong[] uint64Array = (ulong[])(object)destination;
+ fixed (ulong* destinationBase = uint64Array)
{
for (int g = 0; g < Count; g++)
{
- destinationBase[startIndex + g] = (UInt64)(object)this[g];
+ destinationBase[startIndex + g] = (ulong)(object)this[g];
}
}
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64[] int64Array = (Int64[])(object)destination;
- fixed (Int64* destinationBase = int64Array)
+ long[] int64Array = (long[])(object)destination;
+ fixed (long* destinationBase = int64Array)
{
for (int g = 0; g < Count; g++)
{
- destinationBase[startIndex + g] = (Int64)(object)this[g];
+ destinationBase[startIndex + g] = (long)(object)this[g];
}
}
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single[] singleArray = (Single[])(object)destination;
- fixed (Single* destinationBase = singleArray)
+ float[] singleArray = (float[])(object)destination;
+ fixed (float* destinationBase = singleArray)
{
for (int g = 0; g < Count; g++)
{
- destinationBase[startIndex + g] = (Single)(object)this[g];
+ destinationBase[startIndex + g] = (float)(object)this[g];
}
}
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double[] doubleArray = (Double[])(object)destination;
- fixed (Double* destinationBase = doubleArray)
+ double[] doubleArray = (double[])(object)destination;
+ fixed (double* destinationBase = doubleArray)
{
for (int g = 0; g < Count; g++)
{
- destinationBase[startIndex + g] = (Double)(object)this[g];
+ destinationBase[startIndex + g] = (double)(object)this[g];
}
}
}
}
else
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- Byte[] byteArray = (Byte[])(object)destination;
- fixed (Byte* destinationBase = byteArray)
+ byte[] byteArray = (byte[])(object)destination;
+ fixed (byte* destinationBase = byteArray)
{
destinationBase[startIndex + 0] = this.register.byte_0;
destinationBase[startIndex + 1] = this.register.byte_1;
destinationBase[startIndex + 15] = this.register.byte_15;
}
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- SByte[] sbyteArray = (SByte[])(object)destination;
- fixed (SByte* destinationBase = sbyteArray)
+ sbyte[] sbyteArray = (sbyte[])(object)destination;
+ fixed (sbyte* destinationBase = sbyteArray)
{
destinationBase[startIndex + 0] = this.register.sbyte_0;
destinationBase[startIndex + 1] = this.register.sbyte_1;
destinationBase[startIndex + 15] = this.register.sbyte_15;
}
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- UInt16[] uint16Array = (UInt16[])(object)destination;
- fixed (UInt16* destinationBase = uint16Array)
+ ushort[] uint16Array = (ushort[])(object)destination;
+ fixed (ushort* destinationBase = uint16Array)
{
destinationBase[startIndex + 0] = this.register.uint16_0;
destinationBase[startIndex + 1] = this.register.uint16_1;
destinationBase[startIndex + 7] = this.register.uint16_7;
}
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16[] int16Array = (Int16[])(object)destination;
- fixed (Int16* destinationBase = int16Array)
+ short[] int16Array = (short[])(object)destination;
+ fixed (short* destinationBase = int16Array)
{
destinationBase[startIndex + 0] = this.register.int16_0;
destinationBase[startIndex + 1] = this.register.int16_1;
destinationBase[startIndex + 7] = this.register.int16_7;
}
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32[] uint32Array = (UInt32[])(object)destination;
- fixed (UInt32* destinationBase = uint32Array)
+ uint[] uint32Array = (uint[])(object)destination;
+ fixed (uint* destinationBase = uint32Array)
{
destinationBase[startIndex + 0] = this.register.uint32_0;
destinationBase[startIndex + 1] = this.register.uint32_1;
destinationBase[startIndex + 3] = this.register.uint32_3;
}
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32[] int32Array = (Int32[])(object)destination;
- fixed (Int32* destinationBase = int32Array)
+ int[] int32Array = (int[])(object)destination;
+ fixed (int* destinationBase = int32Array)
{
destinationBase[startIndex + 0] = this.register.int32_0;
destinationBase[startIndex + 1] = this.register.int32_1;
destinationBase[startIndex + 3] = this.register.int32_3;
}
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64[] uint64Array = (UInt64[])(object)destination;
- fixed (UInt64* destinationBase = uint64Array)
+ ulong[] uint64Array = (ulong[])(object)destination;
+ fixed (ulong* destinationBase = uint64Array)
{
destinationBase[startIndex + 0] = this.register.uint64_0;
destinationBase[startIndex + 1] = this.register.uint64_1;
}
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64[] int64Array = (Int64[])(object)destination;
- fixed (Int64* destinationBase = int64Array)
+ long[] int64Array = (long[])(object)destination;
+ fixed (long* destinationBase = int64Array)
{
destinationBase[startIndex + 0] = this.register.int64_0;
destinationBase[startIndex + 1] = this.register.int64_1;
}
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single[] singleArray = (Single[])(object)destination;
- fixed (Single* destinationBase = singleArray)
+ float[] singleArray = (float[])(object)destination;
+ fixed (float* destinationBase = singleArray)
{
destinationBase[startIndex + 0] = this.register.single_0;
destinationBase[startIndex + 1] = this.register.single_1;
destinationBase[startIndex + 3] = this.register.single_3;
}
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double[] doubleArray = (Double[])(object)destination;
- fixed (Double* destinationBase = doubleArray)
+ double[] doubleArray = (double[])(object)destination;
+ fixed (double* destinationBase = doubleArray)
{
destinationBase[startIndex + 0] = this.register.double_0;
destinationBase[startIndex + 1] = this.register.double_1;
{
throw new IndexOutOfRangeException(SR.Format(SR.Arg_ArgumentOutOfRangeException, index));
}
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- fixed (Byte* basePtr = &this.register.byte_0)
+ fixed (byte* basePtr = &this.register.byte_0)
{
return (T)(object)*(basePtr + index);
}
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- fixed (SByte* basePtr = &this.register.sbyte_0)
+ fixed (sbyte* basePtr = &this.register.sbyte_0)
{
return (T)(object)*(basePtr + index);
}
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- fixed (UInt16* basePtr = &this.register.uint16_0)
+ fixed (ushort* basePtr = &this.register.uint16_0)
{
return (T)(object)*(basePtr + index);
}
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- fixed (Int16* basePtr = &this.register.int16_0)
+ fixed (short* basePtr = &this.register.int16_0)
{
return (T)(object)*(basePtr + index);
}
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- fixed (UInt32* basePtr = &this.register.uint32_0)
+ fixed (uint* basePtr = &this.register.uint32_0)
{
return (T)(object)*(basePtr + index);
}
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- fixed (Int32* basePtr = &this.register.int32_0)
+ fixed (int* basePtr = &this.register.int32_0)
{
return (T)(object)*(basePtr + index);
}
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- fixed (UInt64* basePtr = &this.register.uint64_0)
+ fixed (ulong* basePtr = &this.register.uint64_0)
{
return (T)(object)*(basePtr + index);
}
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- fixed (Int64* basePtr = &this.register.int64_0)
+ fixed (long* basePtr = &this.register.int64_0)
{
return (T)(object)*(basePtr + index);
}
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- fixed (Single* basePtr = &this.register.single_0)
+ fixed (float* basePtr = &this.register.single_0)
{
return (T)(object)*(basePtr + index);
}
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- fixed (Double* basePtr = &this.register.double_0)
+ fixed (double* basePtr = &this.register.double_0)
{
return (T)(object)*(basePtr + index);
}
}
else
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
return
this.register.byte_0 == other.register.byte_0
&& this.register.byte_14 == other.register.byte_14
&& this.register.byte_15 == other.register.byte_15;
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
return
this.register.sbyte_0 == other.register.sbyte_0
&& this.register.sbyte_14 == other.register.sbyte_14
&& this.register.sbyte_15 == other.register.sbyte_15;
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
return
this.register.uint16_0 == other.register.uint16_0
&& this.register.uint16_6 == other.register.uint16_6
&& this.register.uint16_7 == other.register.uint16_7;
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
return
this.register.int16_0 == other.register.int16_0
&& this.register.int16_6 == other.register.int16_6
&& this.register.int16_7 == other.register.int16_7;
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
return
this.register.uint32_0 == other.register.uint32_0
&& this.register.uint32_2 == other.register.uint32_2
&& this.register.uint32_3 == other.register.uint32_3;
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
return
this.register.int32_0 == other.register.int32_0
&& this.register.int32_2 == other.register.int32_2
&& this.register.int32_3 == other.register.int32_3;
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
return
this.register.uint64_0 == other.register.uint64_0
&& this.register.uint64_1 == other.register.uint64_1;
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
return
this.register.int64_0 == other.register.int64_0
&& this.register.int64_1 == other.register.int64_1;
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
return
this.register.single_0 == other.register.single_0
&& this.register.single_2 == other.register.single_2
&& this.register.single_3 == other.register.single_3;
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
return
this.register.double_0 == other.register.double_0
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
for (int g = 0; g < Count; g++)
{
- hash = HashHelpers.Combine(hash, ((Byte)(object)this[g]).GetHashCode());
+ hash = HashHelpers.Combine(hash, ((byte)(object)this[g]).GetHashCode());
}
return hash;
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
for (int g = 0; g < Count; g++)
{
- hash = HashHelpers.Combine(hash, ((SByte)(object)this[g]).GetHashCode());
+ hash = HashHelpers.Combine(hash, ((sbyte)(object)this[g]).GetHashCode());
}
return hash;
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
for (int g = 0; g < Count; g++)
{
- hash = HashHelpers.Combine(hash, ((UInt16)(object)this[g]).GetHashCode());
+ hash = HashHelpers.Combine(hash, ((ushort)(object)this[g]).GetHashCode());
}
return hash;
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
for (int g = 0; g < Count; g++)
{
- hash = HashHelpers.Combine(hash, ((Int16)(object)this[g]).GetHashCode());
+ hash = HashHelpers.Combine(hash, ((short)(object)this[g]).GetHashCode());
}
return hash;
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
for (int g = 0; g < Count; g++)
{
- hash = HashHelpers.Combine(hash, ((UInt32)(object)this[g]).GetHashCode());
+ hash = HashHelpers.Combine(hash, ((uint)(object)this[g]).GetHashCode());
}
return hash;
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
for (int g = 0; g < Count; g++)
{
- hash = HashHelpers.Combine(hash, ((Int32)(object)this[g]).GetHashCode());
+ hash = HashHelpers.Combine(hash, ((int)(object)this[g]).GetHashCode());
}
return hash;
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
for (int g = 0; g < Count; g++)
{
- hash = HashHelpers.Combine(hash, ((UInt64)(object)this[g]).GetHashCode());
+ hash = HashHelpers.Combine(hash, ((ulong)(object)this[g]).GetHashCode());
}
return hash;
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
for (int g = 0; g < Count; g++)
{
- hash = HashHelpers.Combine(hash, ((Int64)(object)this[g]).GetHashCode());
+ hash = HashHelpers.Combine(hash, ((long)(object)this[g]).GetHashCode());
}
return hash;
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
for (int g = 0; g < Count; g++)
{
- hash = HashHelpers.Combine(hash, ((Single)(object)this[g]).GetHashCode());
+ hash = HashHelpers.Combine(hash, ((float)(object)this[g]).GetHashCode());
}
return hash;
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
for (int g = 0; g < Count; g++)
{
- hash = HashHelpers.Combine(hash, ((Double)(object)this[g]).GetHashCode());
+ hash = HashHelpers.Combine(hash, ((double)(object)this[g]).GetHashCode());
}
return hash;
}
}
else
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
hash = HashHelpers.Combine(hash, this.register.byte_0.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.byte_1.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.byte_15.GetHashCode());
return hash;
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
hash = HashHelpers.Combine(hash, this.register.sbyte_0.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.sbyte_1.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.sbyte_15.GetHashCode());
return hash;
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
hash = HashHelpers.Combine(hash, this.register.uint16_0.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.uint16_1.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.uint16_7.GetHashCode());
return hash;
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
hash = HashHelpers.Combine(hash, this.register.int16_0.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.int16_1.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.int16_7.GetHashCode());
return hash;
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
hash = HashHelpers.Combine(hash, this.register.uint32_0.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.uint32_1.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.uint32_3.GetHashCode());
return hash;
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
hash = HashHelpers.Combine(hash, this.register.int32_0.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.int32_1.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.int32_3.GetHashCode());
return hash;
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
hash = HashHelpers.Combine(hash, this.register.uint64_0.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.uint64_1.GetHashCode());
return hash;
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
hash = HashHelpers.Combine(hash, this.register.int64_0.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.int64_1.GetHashCode());
return hash;
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
hash = HashHelpers.Combine(hash, this.register.single_0.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.single_1.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.single_3.GetHashCode());
return hash;
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
hash = HashHelpers.Combine(hash, this.register.double_0.GetHashCode());
hash = HashHelpers.Combine(hash, this.register.double_1.GetHashCode());
{
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- Byte* dataPtr = stackalloc Byte[Count];
+ byte* dataPtr = stackalloc byte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Byte)(object)ScalarAdd(left[g], right[g]);
+ dataPtr[g] = (byte)(object)ScalarAdd(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- SByte* dataPtr = stackalloc SByte[Count];
+ sbyte* dataPtr = stackalloc sbyte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (SByte)(object)ScalarAdd(left[g], right[g]);
+ dataPtr[g] = (sbyte)(object)ScalarAdd(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- UInt16* dataPtr = stackalloc UInt16[Count];
+ ushort* dataPtr = stackalloc ushort[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (UInt16)(object)ScalarAdd(left[g], right[g]);
+ dataPtr[g] = (ushort)(object)ScalarAdd(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16* dataPtr = stackalloc Int16[Count];
+ short* dataPtr = stackalloc short[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int16)(object)ScalarAdd(left[g], right[g]);
+ dataPtr[g] = (short)(object)ScalarAdd(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32* dataPtr = stackalloc UInt32[Count];
+ uint* dataPtr = stackalloc uint[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (UInt32)(object)ScalarAdd(left[g], right[g]);
+ dataPtr[g] = (uint)(object)ScalarAdd(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32* dataPtr = stackalloc Int32[Count];
+ int* dataPtr = stackalloc int[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int32)(object)ScalarAdd(left[g], right[g]);
+ dataPtr[g] = (int)(object)ScalarAdd(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64* dataPtr = stackalloc UInt64[Count];
+ ulong* dataPtr = stackalloc ulong[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (UInt64)(object)ScalarAdd(left[g], right[g]);
+ dataPtr[g] = (ulong)(object)ScalarAdd(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64* dataPtr = stackalloc Int64[Count];
+ long* dataPtr = stackalloc long[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int64)(object)ScalarAdd(left[g], right[g]);
+ dataPtr[g] = (long)(object)ScalarAdd(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single* dataPtr = stackalloc Single[Count];
+ float* dataPtr = stackalloc float[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Single)(object)ScalarAdd(left[g], right[g]);
+ dataPtr[g] = (float)(object)ScalarAdd(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double* dataPtr = stackalloc Double[Count];
+ double* dataPtr = stackalloc double[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Double)(object)ScalarAdd(left[g], right[g]);
+ dataPtr[g] = (double)(object)ScalarAdd(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
else
{
Vector<T> sum = new Vector<T>();
- if (typeof(T) == typeof(Byte))
- {
- sum.register.byte_0 = (Byte)(left.register.byte_0 + right.register.byte_0);
- sum.register.byte_1 = (Byte)(left.register.byte_1 + right.register.byte_1);
- sum.register.byte_2 = (Byte)(left.register.byte_2 + right.register.byte_2);
- sum.register.byte_3 = (Byte)(left.register.byte_3 + right.register.byte_3);
- sum.register.byte_4 = (Byte)(left.register.byte_4 + right.register.byte_4);
- sum.register.byte_5 = (Byte)(left.register.byte_5 + right.register.byte_5);
- sum.register.byte_6 = (Byte)(left.register.byte_6 + right.register.byte_6);
- sum.register.byte_7 = (Byte)(left.register.byte_7 + right.register.byte_7);
- sum.register.byte_8 = (Byte)(left.register.byte_8 + right.register.byte_8);
- sum.register.byte_9 = (Byte)(left.register.byte_9 + right.register.byte_9);
- sum.register.byte_10 = (Byte)(left.register.byte_10 + right.register.byte_10);
- sum.register.byte_11 = (Byte)(left.register.byte_11 + right.register.byte_11);
- sum.register.byte_12 = (Byte)(left.register.byte_12 + right.register.byte_12);
- sum.register.byte_13 = (Byte)(left.register.byte_13 + right.register.byte_13);
- sum.register.byte_14 = (Byte)(left.register.byte_14 + right.register.byte_14);
- sum.register.byte_15 = (Byte)(left.register.byte_15 + right.register.byte_15);
- }
- else if (typeof(T) == typeof(SByte))
- {
- sum.register.sbyte_0 = (SByte)(left.register.sbyte_0 + right.register.sbyte_0);
- sum.register.sbyte_1 = (SByte)(left.register.sbyte_1 + right.register.sbyte_1);
- sum.register.sbyte_2 = (SByte)(left.register.sbyte_2 + right.register.sbyte_2);
- sum.register.sbyte_3 = (SByte)(left.register.sbyte_3 + right.register.sbyte_3);
- sum.register.sbyte_4 = (SByte)(left.register.sbyte_4 + right.register.sbyte_4);
- sum.register.sbyte_5 = (SByte)(left.register.sbyte_5 + right.register.sbyte_5);
- sum.register.sbyte_6 = (SByte)(left.register.sbyte_6 + right.register.sbyte_6);
- sum.register.sbyte_7 = (SByte)(left.register.sbyte_7 + right.register.sbyte_7);
- sum.register.sbyte_8 = (SByte)(left.register.sbyte_8 + right.register.sbyte_8);
- sum.register.sbyte_9 = (SByte)(left.register.sbyte_9 + right.register.sbyte_9);
- sum.register.sbyte_10 = (SByte)(left.register.sbyte_10 + right.register.sbyte_10);
- sum.register.sbyte_11 = (SByte)(left.register.sbyte_11 + right.register.sbyte_11);
- sum.register.sbyte_12 = (SByte)(left.register.sbyte_12 + right.register.sbyte_12);
- sum.register.sbyte_13 = (SByte)(left.register.sbyte_13 + right.register.sbyte_13);
- sum.register.sbyte_14 = (SByte)(left.register.sbyte_14 + right.register.sbyte_14);
- sum.register.sbyte_15 = (SByte)(left.register.sbyte_15 + right.register.sbyte_15);
- }
- else if (typeof(T) == typeof(UInt16))
- {
- sum.register.uint16_0 = (UInt16)(left.register.uint16_0 + right.register.uint16_0);
- sum.register.uint16_1 = (UInt16)(left.register.uint16_1 + right.register.uint16_1);
- sum.register.uint16_2 = (UInt16)(left.register.uint16_2 + right.register.uint16_2);
- sum.register.uint16_3 = (UInt16)(left.register.uint16_3 + right.register.uint16_3);
- sum.register.uint16_4 = (UInt16)(left.register.uint16_4 + right.register.uint16_4);
- sum.register.uint16_5 = (UInt16)(left.register.uint16_5 + right.register.uint16_5);
- sum.register.uint16_6 = (UInt16)(left.register.uint16_6 + right.register.uint16_6);
- sum.register.uint16_7 = (UInt16)(left.register.uint16_7 + right.register.uint16_7);
- }
- else if (typeof(T) == typeof(Int16))
- {
- sum.register.int16_0 = (Int16)(left.register.int16_0 + right.register.int16_0);
- sum.register.int16_1 = (Int16)(left.register.int16_1 + right.register.int16_1);
- sum.register.int16_2 = (Int16)(left.register.int16_2 + right.register.int16_2);
- sum.register.int16_3 = (Int16)(left.register.int16_3 + right.register.int16_3);
- sum.register.int16_4 = (Int16)(left.register.int16_4 + right.register.int16_4);
- sum.register.int16_5 = (Int16)(left.register.int16_5 + right.register.int16_5);
- sum.register.int16_6 = (Int16)(left.register.int16_6 + right.register.int16_6);
- sum.register.int16_7 = (Int16)(left.register.int16_7 + right.register.int16_7);
- }
- else if (typeof(T) == typeof(UInt32))
- {
- sum.register.uint32_0 = (UInt32)(left.register.uint32_0 + right.register.uint32_0);
- sum.register.uint32_1 = (UInt32)(left.register.uint32_1 + right.register.uint32_1);
- sum.register.uint32_2 = (UInt32)(left.register.uint32_2 + right.register.uint32_2);
- sum.register.uint32_3 = (UInt32)(left.register.uint32_3 + right.register.uint32_3);
- }
- else if (typeof(T) == typeof(Int32))
- {
- sum.register.int32_0 = (Int32)(left.register.int32_0 + right.register.int32_0);
- sum.register.int32_1 = (Int32)(left.register.int32_1 + right.register.int32_1);
- sum.register.int32_2 = (Int32)(left.register.int32_2 + right.register.int32_2);
- sum.register.int32_3 = (Int32)(left.register.int32_3 + right.register.int32_3);
- }
- else if (typeof(T) == typeof(UInt64))
- {
- sum.register.uint64_0 = (UInt64)(left.register.uint64_0 + right.register.uint64_0);
- sum.register.uint64_1 = (UInt64)(left.register.uint64_1 + right.register.uint64_1);
- }
- else if (typeof(T) == typeof(Int64))
- {
- sum.register.int64_0 = (Int64)(left.register.int64_0 + right.register.int64_0);
- sum.register.int64_1 = (Int64)(left.register.int64_1 + right.register.int64_1);
- }
- else if (typeof(T) == typeof(Single))
- {
- sum.register.single_0 = (Single)(left.register.single_0 + right.register.single_0);
- sum.register.single_1 = (Single)(left.register.single_1 + right.register.single_1);
- sum.register.single_2 = (Single)(left.register.single_2 + right.register.single_2);
- sum.register.single_3 = (Single)(left.register.single_3 + right.register.single_3);
- }
- else if (typeof(T) == typeof(Double))
- {
- sum.register.double_0 = (Double)(left.register.double_0 + right.register.double_0);
- sum.register.double_1 = (Double)(left.register.double_1 + right.register.double_1);
+ if (typeof(T) == typeof(byte))
+ {
+ sum.register.byte_0 = (byte)(left.register.byte_0 + right.register.byte_0);
+ sum.register.byte_1 = (byte)(left.register.byte_1 + right.register.byte_1);
+ sum.register.byte_2 = (byte)(left.register.byte_2 + right.register.byte_2);
+ sum.register.byte_3 = (byte)(left.register.byte_3 + right.register.byte_3);
+ sum.register.byte_4 = (byte)(left.register.byte_4 + right.register.byte_4);
+ sum.register.byte_5 = (byte)(left.register.byte_5 + right.register.byte_5);
+ sum.register.byte_6 = (byte)(left.register.byte_6 + right.register.byte_6);
+ sum.register.byte_7 = (byte)(left.register.byte_7 + right.register.byte_7);
+ sum.register.byte_8 = (byte)(left.register.byte_8 + right.register.byte_8);
+ sum.register.byte_9 = (byte)(left.register.byte_9 + right.register.byte_9);
+ sum.register.byte_10 = (byte)(left.register.byte_10 + right.register.byte_10);
+ sum.register.byte_11 = (byte)(left.register.byte_11 + right.register.byte_11);
+ sum.register.byte_12 = (byte)(left.register.byte_12 + right.register.byte_12);
+ sum.register.byte_13 = (byte)(left.register.byte_13 + right.register.byte_13);
+ sum.register.byte_14 = (byte)(left.register.byte_14 + right.register.byte_14);
+ sum.register.byte_15 = (byte)(left.register.byte_15 + right.register.byte_15);
+ }
+ else if (typeof(T) == typeof(sbyte))
+ {
+ sum.register.sbyte_0 = (sbyte)(left.register.sbyte_0 + right.register.sbyte_0);
+ sum.register.sbyte_1 = (sbyte)(left.register.sbyte_1 + right.register.sbyte_1);
+ sum.register.sbyte_2 = (sbyte)(left.register.sbyte_2 + right.register.sbyte_2);
+ sum.register.sbyte_3 = (sbyte)(left.register.sbyte_3 + right.register.sbyte_3);
+ sum.register.sbyte_4 = (sbyte)(left.register.sbyte_4 + right.register.sbyte_4);
+ sum.register.sbyte_5 = (sbyte)(left.register.sbyte_5 + right.register.sbyte_5);
+ sum.register.sbyte_6 = (sbyte)(left.register.sbyte_6 + right.register.sbyte_6);
+ sum.register.sbyte_7 = (sbyte)(left.register.sbyte_7 + right.register.sbyte_7);
+ sum.register.sbyte_8 = (sbyte)(left.register.sbyte_8 + right.register.sbyte_8);
+ sum.register.sbyte_9 = (sbyte)(left.register.sbyte_9 + right.register.sbyte_9);
+ sum.register.sbyte_10 = (sbyte)(left.register.sbyte_10 + right.register.sbyte_10);
+ sum.register.sbyte_11 = (sbyte)(left.register.sbyte_11 + right.register.sbyte_11);
+ sum.register.sbyte_12 = (sbyte)(left.register.sbyte_12 + right.register.sbyte_12);
+ sum.register.sbyte_13 = (sbyte)(left.register.sbyte_13 + right.register.sbyte_13);
+ sum.register.sbyte_14 = (sbyte)(left.register.sbyte_14 + right.register.sbyte_14);
+ sum.register.sbyte_15 = (sbyte)(left.register.sbyte_15 + right.register.sbyte_15);
+ }
+ else if (typeof(T) == typeof(ushort))
+ {
+ sum.register.uint16_0 = (ushort)(left.register.uint16_0 + right.register.uint16_0);
+ sum.register.uint16_1 = (ushort)(left.register.uint16_1 + right.register.uint16_1);
+ sum.register.uint16_2 = (ushort)(left.register.uint16_2 + right.register.uint16_2);
+ sum.register.uint16_3 = (ushort)(left.register.uint16_3 + right.register.uint16_3);
+ sum.register.uint16_4 = (ushort)(left.register.uint16_4 + right.register.uint16_4);
+ sum.register.uint16_5 = (ushort)(left.register.uint16_5 + right.register.uint16_5);
+ sum.register.uint16_6 = (ushort)(left.register.uint16_6 + right.register.uint16_6);
+ sum.register.uint16_7 = (ushort)(left.register.uint16_7 + right.register.uint16_7);
+ }
+ else if (typeof(T) == typeof(short))
+ {
+ sum.register.int16_0 = (short)(left.register.int16_0 + right.register.int16_0);
+ sum.register.int16_1 = (short)(left.register.int16_1 + right.register.int16_1);
+ sum.register.int16_2 = (short)(left.register.int16_2 + right.register.int16_2);
+ sum.register.int16_3 = (short)(left.register.int16_3 + right.register.int16_3);
+ sum.register.int16_4 = (short)(left.register.int16_4 + right.register.int16_4);
+ sum.register.int16_5 = (short)(left.register.int16_5 + right.register.int16_5);
+ sum.register.int16_6 = (short)(left.register.int16_6 + right.register.int16_6);
+ sum.register.int16_7 = (short)(left.register.int16_7 + right.register.int16_7);
+ }
+ else if (typeof(T) == typeof(uint))
+ {
+ sum.register.uint32_0 = (uint)(left.register.uint32_0 + right.register.uint32_0);
+ sum.register.uint32_1 = (uint)(left.register.uint32_1 + right.register.uint32_1);
+ sum.register.uint32_2 = (uint)(left.register.uint32_2 + right.register.uint32_2);
+ sum.register.uint32_3 = (uint)(left.register.uint32_3 + right.register.uint32_3);
+ }
+ else if (typeof(T) == typeof(int))
+ {
+ sum.register.int32_0 = (int)(left.register.int32_0 + right.register.int32_0);
+ sum.register.int32_1 = (int)(left.register.int32_1 + right.register.int32_1);
+ sum.register.int32_2 = (int)(left.register.int32_2 + right.register.int32_2);
+ sum.register.int32_3 = (int)(left.register.int32_3 + right.register.int32_3);
+ }
+ else if (typeof(T) == typeof(ulong))
+ {
+ sum.register.uint64_0 = (ulong)(left.register.uint64_0 + right.register.uint64_0);
+ sum.register.uint64_1 = (ulong)(left.register.uint64_1 + right.register.uint64_1);
+ }
+ else if (typeof(T) == typeof(long))
+ {
+ sum.register.int64_0 = (long)(left.register.int64_0 + right.register.int64_0);
+ sum.register.int64_1 = (long)(left.register.int64_1 + right.register.int64_1);
+ }
+ else if (typeof(T) == typeof(float))
+ {
+ sum.register.single_0 = (float)(left.register.single_0 + right.register.single_0);
+ sum.register.single_1 = (float)(left.register.single_1 + right.register.single_1);
+ sum.register.single_2 = (float)(left.register.single_2 + right.register.single_2);
+ sum.register.single_3 = (float)(left.register.single_3 + right.register.single_3);
+ }
+ else if (typeof(T) == typeof(double))
+ {
+ sum.register.double_0 = (double)(left.register.double_0 + right.register.double_0);
+ sum.register.double_1 = (double)(left.register.double_1 + right.register.double_1);
}
return sum;
}
{
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- Byte* dataPtr = stackalloc Byte[Count];
+ byte* dataPtr = stackalloc byte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Byte)(object)ScalarSubtract(left[g], right[g]);
+ dataPtr[g] = (byte)(object)ScalarSubtract(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- SByte* dataPtr = stackalloc SByte[Count];
+ sbyte* dataPtr = stackalloc sbyte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (SByte)(object)ScalarSubtract(left[g], right[g]);
+ dataPtr[g] = (sbyte)(object)ScalarSubtract(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- UInt16* dataPtr = stackalloc UInt16[Count];
+ ushort* dataPtr = stackalloc ushort[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (UInt16)(object)ScalarSubtract(left[g], right[g]);
+ dataPtr[g] = (ushort)(object)ScalarSubtract(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16* dataPtr = stackalloc Int16[Count];
+ short* dataPtr = stackalloc short[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int16)(object)ScalarSubtract(left[g], right[g]);
+ dataPtr[g] = (short)(object)ScalarSubtract(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32* dataPtr = stackalloc UInt32[Count];
+ uint* dataPtr = stackalloc uint[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (UInt32)(object)ScalarSubtract(left[g], right[g]);
+ dataPtr[g] = (uint)(object)ScalarSubtract(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32* dataPtr = stackalloc Int32[Count];
+ int* dataPtr = stackalloc int[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int32)(object)ScalarSubtract(left[g], right[g]);
+ dataPtr[g] = (int)(object)ScalarSubtract(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64* dataPtr = stackalloc UInt64[Count];
+ ulong* dataPtr = stackalloc ulong[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (UInt64)(object)ScalarSubtract(left[g], right[g]);
+ dataPtr[g] = (ulong)(object)ScalarSubtract(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64* dataPtr = stackalloc Int64[Count];
+ long* dataPtr = stackalloc long[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int64)(object)ScalarSubtract(left[g], right[g]);
+ dataPtr[g] = (long)(object)ScalarSubtract(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single* dataPtr = stackalloc Single[Count];
+ float* dataPtr = stackalloc float[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Single)(object)ScalarSubtract(left[g], right[g]);
+ dataPtr[g] = (float)(object)ScalarSubtract(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double* dataPtr = stackalloc Double[Count];
+ double* dataPtr = stackalloc double[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Double)(object)ScalarSubtract(left[g], right[g]);
+ dataPtr[g] = (double)(object)ScalarSubtract(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
else
{
Vector<T> difference = new Vector<T>();
- if (typeof(T) == typeof(Byte))
- {
- difference.register.byte_0 = (Byte)(left.register.byte_0 - right.register.byte_0);
- difference.register.byte_1 = (Byte)(left.register.byte_1 - right.register.byte_1);
- difference.register.byte_2 = (Byte)(left.register.byte_2 - right.register.byte_2);
- difference.register.byte_3 = (Byte)(left.register.byte_3 - right.register.byte_3);
- difference.register.byte_4 = (Byte)(left.register.byte_4 - right.register.byte_4);
- difference.register.byte_5 = (Byte)(left.register.byte_5 - right.register.byte_5);
- difference.register.byte_6 = (Byte)(left.register.byte_6 - right.register.byte_6);
- difference.register.byte_7 = (Byte)(left.register.byte_7 - right.register.byte_7);
- difference.register.byte_8 = (Byte)(left.register.byte_8 - right.register.byte_8);
- difference.register.byte_9 = (Byte)(left.register.byte_9 - right.register.byte_9);
- difference.register.byte_10 = (Byte)(left.register.byte_10 - right.register.byte_10);
- difference.register.byte_11 = (Byte)(left.register.byte_11 - right.register.byte_11);
- difference.register.byte_12 = (Byte)(left.register.byte_12 - right.register.byte_12);
- difference.register.byte_13 = (Byte)(left.register.byte_13 - right.register.byte_13);
- difference.register.byte_14 = (Byte)(left.register.byte_14 - right.register.byte_14);
- difference.register.byte_15 = (Byte)(left.register.byte_15 - right.register.byte_15);
- }
- else if (typeof(T) == typeof(SByte))
- {
- difference.register.sbyte_0 = (SByte)(left.register.sbyte_0 - right.register.sbyte_0);
- difference.register.sbyte_1 = (SByte)(left.register.sbyte_1 - right.register.sbyte_1);
- difference.register.sbyte_2 = (SByte)(left.register.sbyte_2 - right.register.sbyte_2);
- difference.register.sbyte_3 = (SByte)(left.register.sbyte_3 - right.register.sbyte_3);
- difference.register.sbyte_4 = (SByte)(left.register.sbyte_4 - right.register.sbyte_4);
- difference.register.sbyte_5 = (SByte)(left.register.sbyte_5 - right.register.sbyte_5);
- difference.register.sbyte_6 = (SByte)(left.register.sbyte_6 - right.register.sbyte_6);
- difference.register.sbyte_7 = (SByte)(left.register.sbyte_7 - right.register.sbyte_7);
- difference.register.sbyte_8 = (SByte)(left.register.sbyte_8 - right.register.sbyte_8);
- difference.register.sbyte_9 = (SByte)(left.register.sbyte_9 - right.register.sbyte_9);
- difference.register.sbyte_10 = (SByte)(left.register.sbyte_10 - right.register.sbyte_10);
- difference.register.sbyte_11 = (SByte)(left.register.sbyte_11 - right.register.sbyte_11);
- difference.register.sbyte_12 = (SByte)(left.register.sbyte_12 - right.register.sbyte_12);
- difference.register.sbyte_13 = (SByte)(left.register.sbyte_13 - right.register.sbyte_13);
- difference.register.sbyte_14 = (SByte)(left.register.sbyte_14 - right.register.sbyte_14);
- difference.register.sbyte_15 = (SByte)(left.register.sbyte_15 - right.register.sbyte_15);
- }
- else if (typeof(T) == typeof(UInt16))
- {
- difference.register.uint16_0 = (UInt16)(left.register.uint16_0 - right.register.uint16_0);
- difference.register.uint16_1 = (UInt16)(left.register.uint16_1 - right.register.uint16_1);
- difference.register.uint16_2 = (UInt16)(left.register.uint16_2 - right.register.uint16_2);
- difference.register.uint16_3 = (UInt16)(left.register.uint16_3 - right.register.uint16_3);
- difference.register.uint16_4 = (UInt16)(left.register.uint16_4 - right.register.uint16_4);
- difference.register.uint16_5 = (UInt16)(left.register.uint16_5 - right.register.uint16_5);
- difference.register.uint16_6 = (UInt16)(left.register.uint16_6 - right.register.uint16_6);
- difference.register.uint16_7 = (UInt16)(left.register.uint16_7 - right.register.uint16_7);
- }
- else if (typeof(T) == typeof(Int16))
- {
- difference.register.int16_0 = (Int16)(left.register.int16_0 - right.register.int16_0);
- difference.register.int16_1 = (Int16)(left.register.int16_1 - right.register.int16_1);
- difference.register.int16_2 = (Int16)(left.register.int16_2 - right.register.int16_2);
- difference.register.int16_3 = (Int16)(left.register.int16_3 - right.register.int16_3);
- difference.register.int16_4 = (Int16)(left.register.int16_4 - right.register.int16_4);
- difference.register.int16_5 = (Int16)(left.register.int16_5 - right.register.int16_5);
- difference.register.int16_6 = (Int16)(left.register.int16_6 - right.register.int16_6);
- difference.register.int16_7 = (Int16)(left.register.int16_7 - right.register.int16_7);
- }
- else if (typeof(T) == typeof(UInt32))
- {
- difference.register.uint32_0 = (UInt32)(left.register.uint32_0 - right.register.uint32_0);
- difference.register.uint32_1 = (UInt32)(left.register.uint32_1 - right.register.uint32_1);
- difference.register.uint32_2 = (UInt32)(left.register.uint32_2 - right.register.uint32_2);
- difference.register.uint32_3 = (UInt32)(left.register.uint32_3 - right.register.uint32_3);
- }
- else if (typeof(T) == typeof(Int32))
- {
- difference.register.int32_0 = (Int32)(left.register.int32_0 - right.register.int32_0);
- difference.register.int32_1 = (Int32)(left.register.int32_1 - right.register.int32_1);
- difference.register.int32_2 = (Int32)(left.register.int32_2 - right.register.int32_2);
- difference.register.int32_3 = (Int32)(left.register.int32_3 - right.register.int32_3);
- }
- else if (typeof(T) == typeof(UInt64))
- {
- difference.register.uint64_0 = (UInt64)(left.register.uint64_0 - right.register.uint64_0);
- difference.register.uint64_1 = (UInt64)(left.register.uint64_1 - right.register.uint64_1);
- }
- else if (typeof(T) == typeof(Int64))
- {
- difference.register.int64_0 = (Int64)(left.register.int64_0 - right.register.int64_0);
- difference.register.int64_1 = (Int64)(left.register.int64_1 - right.register.int64_1);
- }
- else if (typeof(T) == typeof(Single))
- {
- difference.register.single_0 = (Single)(left.register.single_0 - right.register.single_0);
- difference.register.single_1 = (Single)(left.register.single_1 - right.register.single_1);
- difference.register.single_2 = (Single)(left.register.single_2 - right.register.single_2);
- difference.register.single_3 = (Single)(left.register.single_3 - right.register.single_3);
- }
- else if (typeof(T) == typeof(Double))
- {
- difference.register.double_0 = (Double)(left.register.double_0 - right.register.double_0);
- difference.register.double_1 = (Double)(left.register.double_1 - right.register.double_1);
+ if (typeof(T) == typeof(byte))
+ {
+ difference.register.byte_0 = (byte)(left.register.byte_0 - right.register.byte_0);
+ difference.register.byte_1 = (byte)(left.register.byte_1 - right.register.byte_1);
+ difference.register.byte_2 = (byte)(left.register.byte_2 - right.register.byte_2);
+ difference.register.byte_3 = (byte)(left.register.byte_3 - right.register.byte_3);
+ difference.register.byte_4 = (byte)(left.register.byte_4 - right.register.byte_4);
+ difference.register.byte_5 = (byte)(left.register.byte_5 - right.register.byte_5);
+ difference.register.byte_6 = (byte)(left.register.byte_6 - right.register.byte_6);
+ difference.register.byte_7 = (byte)(left.register.byte_7 - right.register.byte_7);
+ difference.register.byte_8 = (byte)(left.register.byte_8 - right.register.byte_8);
+ difference.register.byte_9 = (byte)(left.register.byte_9 - right.register.byte_9);
+ difference.register.byte_10 = (byte)(left.register.byte_10 - right.register.byte_10);
+ difference.register.byte_11 = (byte)(left.register.byte_11 - right.register.byte_11);
+ difference.register.byte_12 = (byte)(left.register.byte_12 - right.register.byte_12);
+ difference.register.byte_13 = (byte)(left.register.byte_13 - right.register.byte_13);
+ difference.register.byte_14 = (byte)(left.register.byte_14 - right.register.byte_14);
+ difference.register.byte_15 = (byte)(left.register.byte_15 - right.register.byte_15);
+ }
+ else if (typeof(T) == typeof(sbyte))
+ {
+ difference.register.sbyte_0 = (sbyte)(left.register.sbyte_0 - right.register.sbyte_0);
+ difference.register.sbyte_1 = (sbyte)(left.register.sbyte_1 - right.register.sbyte_1);
+ difference.register.sbyte_2 = (sbyte)(left.register.sbyte_2 - right.register.sbyte_2);
+ difference.register.sbyte_3 = (sbyte)(left.register.sbyte_3 - right.register.sbyte_3);
+ difference.register.sbyte_4 = (sbyte)(left.register.sbyte_4 - right.register.sbyte_4);
+ difference.register.sbyte_5 = (sbyte)(left.register.sbyte_5 - right.register.sbyte_5);
+ difference.register.sbyte_6 = (sbyte)(left.register.sbyte_6 - right.register.sbyte_6);
+ difference.register.sbyte_7 = (sbyte)(left.register.sbyte_7 - right.register.sbyte_7);
+ difference.register.sbyte_8 = (sbyte)(left.register.sbyte_8 - right.register.sbyte_8);
+ difference.register.sbyte_9 = (sbyte)(left.register.sbyte_9 - right.register.sbyte_9);
+ difference.register.sbyte_10 = (sbyte)(left.register.sbyte_10 - right.register.sbyte_10);
+ difference.register.sbyte_11 = (sbyte)(left.register.sbyte_11 - right.register.sbyte_11);
+ difference.register.sbyte_12 = (sbyte)(left.register.sbyte_12 - right.register.sbyte_12);
+ difference.register.sbyte_13 = (sbyte)(left.register.sbyte_13 - right.register.sbyte_13);
+ difference.register.sbyte_14 = (sbyte)(left.register.sbyte_14 - right.register.sbyte_14);
+ difference.register.sbyte_15 = (sbyte)(left.register.sbyte_15 - right.register.sbyte_15);
+ }
+ else if (typeof(T) == typeof(ushort))
+ {
+ difference.register.uint16_0 = (ushort)(left.register.uint16_0 - right.register.uint16_0);
+ difference.register.uint16_1 = (ushort)(left.register.uint16_1 - right.register.uint16_1);
+ difference.register.uint16_2 = (ushort)(left.register.uint16_2 - right.register.uint16_2);
+ difference.register.uint16_3 = (ushort)(left.register.uint16_3 - right.register.uint16_3);
+ difference.register.uint16_4 = (ushort)(left.register.uint16_4 - right.register.uint16_4);
+ difference.register.uint16_5 = (ushort)(left.register.uint16_5 - right.register.uint16_5);
+ difference.register.uint16_6 = (ushort)(left.register.uint16_6 - right.register.uint16_6);
+ difference.register.uint16_7 = (ushort)(left.register.uint16_7 - right.register.uint16_7);
+ }
+ else if (typeof(T) == typeof(short))
+ {
+ difference.register.int16_0 = (short)(left.register.int16_0 - right.register.int16_0);
+ difference.register.int16_1 = (short)(left.register.int16_1 - right.register.int16_1);
+ difference.register.int16_2 = (short)(left.register.int16_2 - right.register.int16_2);
+ difference.register.int16_3 = (short)(left.register.int16_3 - right.register.int16_3);
+ difference.register.int16_4 = (short)(left.register.int16_4 - right.register.int16_4);
+ difference.register.int16_5 = (short)(left.register.int16_5 - right.register.int16_5);
+ difference.register.int16_6 = (short)(left.register.int16_6 - right.register.int16_6);
+ difference.register.int16_7 = (short)(left.register.int16_7 - right.register.int16_7);
+ }
+ else if (typeof(T) == typeof(uint))
+ {
+ difference.register.uint32_0 = (uint)(left.register.uint32_0 - right.register.uint32_0);
+ difference.register.uint32_1 = (uint)(left.register.uint32_1 - right.register.uint32_1);
+ difference.register.uint32_2 = (uint)(left.register.uint32_2 - right.register.uint32_2);
+ difference.register.uint32_3 = (uint)(left.register.uint32_3 - right.register.uint32_3);
+ }
+ else if (typeof(T) == typeof(int))
+ {
+ difference.register.int32_0 = (int)(left.register.int32_0 - right.register.int32_0);
+ difference.register.int32_1 = (int)(left.register.int32_1 - right.register.int32_1);
+ difference.register.int32_2 = (int)(left.register.int32_2 - right.register.int32_2);
+ difference.register.int32_3 = (int)(left.register.int32_3 - right.register.int32_3);
+ }
+ else if (typeof(T) == typeof(ulong))
+ {
+ difference.register.uint64_0 = (ulong)(left.register.uint64_0 - right.register.uint64_0);
+ difference.register.uint64_1 = (ulong)(left.register.uint64_1 - right.register.uint64_1);
+ }
+ else if (typeof(T) == typeof(long))
+ {
+ difference.register.int64_0 = (long)(left.register.int64_0 - right.register.int64_0);
+ difference.register.int64_1 = (long)(left.register.int64_1 - right.register.int64_1);
+ }
+ else if (typeof(T) == typeof(float))
+ {
+ difference.register.single_0 = (float)(left.register.single_0 - right.register.single_0);
+ difference.register.single_1 = (float)(left.register.single_1 - right.register.single_1);
+ difference.register.single_2 = (float)(left.register.single_2 - right.register.single_2);
+ difference.register.single_3 = (float)(left.register.single_3 - right.register.single_3);
+ }
+ else if (typeof(T) == typeof(double))
+ {
+ difference.register.double_0 = (double)(left.register.double_0 - right.register.double_0);
+ difference.register.double_1 = (double)(left.register.double_1 - right.register.double_1);
}
return difference;
}
{
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- Byte* dataPtr = stackalloc Byte[Count];
+ byte* dataPtr = stackalloc byte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Byte)(object)ScalarMultiply(left[g], right[g]);
+ dataPtr[g] = (byte)(object)ScalarMultiply(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- SByte* dataPtr = stackalloc SByte[Count];
+ sbyte* dataPtr = stackalloc sbyte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (SByte)(object)ScalarMultiply(left[g], right[g]);
+ dataPtr[g] = (sbyte)(object)ScalarMultiply(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- UInt16* dataPtr = stackalloc UInt16[Count];
+ ushort* dataPtr = stackalloc ushort[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (UInt16)(object)ScalarMultiply(left[g], right[g]);
+ dataPtr[g] = (ushort)(object)ScalarMultiply(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16* dataPtr = stackalloc Int16[Count];
+ short* dataPtr = stackalloc short[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int16)(object)ScalarMultiply(left[g], right[g]);
+ dataPtr[g] = (short)(object)ScalarMultiply(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32* dataPtr = stackalloc UInt32[Count];
+ uint* dataPtr = stackalloc uint[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (UInt32)(object)ScalarMultiply(left[g], right[g]);
+ dataPtr[g] = (uint)(object)ScalarMultiply(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32* dataPtr = stackalloc Int32[Count];
+ int* dataPtr = stackalloc int[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int32)(object)ScalarMultiply(left[g], right[g]);
+ dataPtr[g] = (int)(object)ScalarMultiply(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64* dataPtr = stackalloc UInt64[Count];
+ ulong* dataPtr = stackalloc ulong[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (UInt64)(object)ScalarMultiply(left[g], right[g]);
+ dataPtr[g] = (ulong)(object)ScalarMultiply(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64* dataPtr = stackalloc Int64[Count];
+ long* dataPtr = stackalloc long[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int64)(object)ScalarMultiply(left[g], right[g]);
+ dataPtr[g] = (long)(object)ScalarMultiply(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single* dataPtr = stackalloc Single[Count];
+ float* dataPtr = stackalloc float[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Single)(object)ScalarMultiply(left[g], right[g]);
+ dataPtr[g] = (float)(object)ScalarMultiply(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double* dataPtr = stackalloc Double[Count];
+ double* dataPtr = stackalloc double[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Double)(object)ScalarMultiply(left[g], right[g]);
+ dataPtr[g] = (double)(object)ScalarMultiply(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
else
{
Vector<T> product = new Vector<T>();
- if (typeof(T) == typeof(Byte))
- {
- product.register.byte_0 = (Byte)(left.register.byte_0 * right.register.byte_0);
- product.register.byte_1 = (Byte)(left.register.byte_1 * right.register.byte_1);
- product.register.byte_2 = (Byte)(left.register.byte_2 * right.register.byte_2);
- product.register.byte_3 = (Byte)(left.register.byte_3 * right.register.byte_3);
- product.register.byte_4 = (Byte)(left.register.byte_4 * right.register.byte_4);
- product.register.byte_5 = (Byte)(left.register.byte_5 * right.register.byte_5);
- product.register.byte_6 = (Byte)(left.register.byte_6 * right.register.byte_6);
- product.register.byte_7 = (Byte)(left.register.byte_7 * right.register.byte_7);
- product.register.byte_8 = (Byte)(left.register.byte_8 * right.register.byte_8);
- product.register.byte_9 = (Byte)(left.register.byte_9 * right.register.byte_9);
- product.register.byte_10 = (Byte)(left.register.byte_10 * right.register.byte_10);
- product.register.byte_11 = (Byte)(left.register.byte_11 * right.register.byte_11);
- product.register.byte_12 = (Byte)(left.register.byte_12 * right.register.byte_12);
- product.register.byte_13 = (Byte)(left.register.byte_13 * right.register.byte_13);
- product.register.byte_14 = (Byte)(left.register.byte_14 * right.register.byte_14);
- product.register.byte_15 = (Byte)(left.register.byte_15 * right.register.byte_15);
- }
- else if (typeof(T) == typeof(SByte))
- {
- product.register.sbyte_0 = (SByte)(left.register.sbyte_0 * right.register.sbyte_0);
- product.register.sbyte_1 = (SByte)(left.register.sbyte_1 * right.register.sbyte_1);
- product.register.sbyte_2 = (SByte)(left.register.sbyte_2 * right.register.sbyte_2);
- product.register.sbyte_3 = (SByte)(left.register.sbyte_3 * right.register.sbyte_3);
- product.register.sbyte_4 = (SByte)(left.register.sbyte_4 * right.register.sbyte_4);
- product.register.sbyte_5 = (SByte)(left.register.sbyte_5 * right.register.sbyte_5);
- product.register.sbyte_6 = (SByte)(left.register.sbyte_6 * right.register.sbyte_6);
- product.register.sbyte_7 = (SByte)(left.register.sbyte_7 * right.register.sbyte_7);
- product.register.sbyte_8 = (SByte)(left.register.sbyte_8 * right.register.sbyte_8);
- product.register.sbyte_9 = (SByte)(left.register.sbyte_9 * right.register.sbyte_9);
- product.register.sbyte_10 = (SByte)(left.register.sbyte_10 * right.register.sbyte_10);
- product.register.sbyte_11 = (SByte)(left.register.sbyte_11 * right.register.sbyte_11);
- product.register.sbyte_12 = (SByte)(left.register.sbyte_12 * right.register.sbyte_12);
- product.register.sbyte_13 = (SByte)(left.register.sbyte_13 * right.register.sbyte_13);
- product.register.sbyte_14 = (SByte)(left.register.sbyte_14 * right.register.sbyte_14);
- product.register.sbyte_15 = (SByte)(left.register.sbyte_15 * right.register.sbyte_15);
- }
- else if (typeof(T) == typeof(UInt16))
- {
- product.register.uint16_0 = (UInt16)(left.register.uint16_0 * right.register.uint16_0);
- product.register.uint16_1 = (UInt16)(left.register.uint16_1 * right.register.uint16_1);
- product.register.uint16_2 = (UInt16)(left.register.uint16_2 * right.register.uint16_2);
- product.register.uint16_3 = (UInt16)(left.register.uint16_3 * right.register.uint16_3);
- product.register.uint16_4 = (UInt16)(left.register.uint16_4 * right.register.uint16_4);
- product.register.uint16_5 = (UInt16)(left.register.uint16_5 * right.register.uint16_5);
- product.register.uint16_6 = (UInt16)(left.register.uint16_6 * right.register.uint16_6);
- product.register.uint16_7 = (UInt16)(left.register.uint16_7 * right.register.uint16_7);
- }
- else if (typeof(T) == typeof(Int16))
- {
- product.register.int16_0 = (Int16)(left.register.int16_0 * right.register.int16_0);
- product.register.int16_1 = (Int16)(left.register.int16_1 * right.register.int16_1);
- product.register.int16_2 = (Int16)(left.register.int16_2 * right.register.int16_2);
- product.register.int16_3 = (Int16)(left.register.int16_3 * right.register.int16_3);
- product.register.int16_4 = (Int16)(left.register.int16_4 * right.register.int16_4);
- product.register.int16_5 = (Int16)(left.register.int16_5 * right.register.int16_5);
- product.register.int16_6 = (Int16)(left.register.int16_6 * right.register.int16_6);
- product.register.int16_7 = (Int16)(left.register.int16_7 * right.register.int16_7);
- }
- else if (typeof(T) == typeof(UInt32))
- {
- product.register.uint32_0 = (UInt32)(left.register.uint32_0 * right.register.uint32_0);
- product.register.uint32_1 = (UInt32)(left.register.uint32_1 * right.register.uint32_1);
- product.register.uint32_2 = (UInt32)(left.register.uint32_2 * right.register.uint32_2);
- product.register.uint32_3 = (UInt32)(left.register.uint32_3 * right.register.uint32_3);
- }
- else if (typeof(T) == typeof(Int32))
- {
- product.register.int32_0 = (Int32)(left.register.int32_0 * right.register.int32_0);
- product.register.int32_1 = (Int32)(left.register.int32_1 * right.register.int32_1);
- product.register.int32_2 = (Int32)(left.register.int32_2 * right.register.int32_2);
- product.register.int32_3 = (Int32)(left.register.int32_3 * right.register.int32_3);
- }
- else if (typeof(T) == typeof(UInt64))
- {
- product.register.uint64_0 = (UInt64)(left.register.uint64_0 * right.register.uint64_0);
- product.register.uint64_1 = (UInt64)(left.register.uint64_1 * right.register.uint64_1);
- }
- else if (typeof(T) == typeof(Int64))
- {
- product.register.int64_0 = (Int64)(left.register.int64_0 * right.register.int64_0);
- product.register.int64_1 = (Int64)(left.register.int64_1 * right.register.int64_1);
- }
- else if (typeof(T) == typeof(Single))
- {
- product.register.single_0 = (Single)(left.register.single_0 * right.register.single_0);
- product.register.single_1 = (Single)(left.register.single_1 * right.register.single_1);
- product.register.single_2 = (Single)(left.register.single_2 * right.register.single_2);
- product.register.single_3 = (Single)(left.register.single_3 * right.register.single_3);
- }
- else if (typeof(T) == typeof(Double))
- {
- product.register.double_0 = (Double)(left.register.double_0 * right.register.double_0);
- product.register.double_1 = (Double)(left.register.double_1 * right.register.double_1);
+ if (typeof(T) == typeof(byte))
+ {
+ product.register.byte_0 = (byte)(left.register.byte_0 * right.register.byte_0);
+ product.register.byte_1 = (byte)(left.register.byte_1 * right.register.byte_1);
+ product.register.byte_2 = (byte)(left.register.byte_2 * right.register.byte_2);
+ product.register.byte_3 = (byte)(left.register.byte_3 * right.register.byte_3);
+ product.register.byte_4 = (byte)(left.register.byte_4 * right.register.byte_4);
+ product.register.byte_5 = (byte)(left.register.byte_5 * right.register.byte_5);
+ product.register.byte_6 = (byte)(left.register.byte_6 * right.register.byte_6);
+ product.register.byte_7 = (byte)(left.register.byte_7 * right.register.byte_7);
+ product.register.byte_8 = (byte)(left.register.byte_8 * right.register.byte_8);
+ product.register.byte_9 = (byte)(left.register.byte_9 * right.register.byte_9);
+ product.register.byte_10 = (byte)(left.register.byte_10 * right.register.byte_10);
+ product.register.byte_11 = (byte)(left.register.byte_11 * right.register.byte_11);
+ product.register.byte_12 = (byte)(left.register.byte_12 * right.register.byte_12);
+ product.register.byte_13 = (byte)(left.register.byte_13 * right.register.byte_13);
+ product.register.byte_14 = (byte)(left.register.byte_14 * right.register.byte_14);
+ product.register.byte_15 = (byte)(left.register.byte_15 * right.register.byte_15);
+ }
+ else if (typeof(T) == typeof(sbyte))
+ {
+ product.register.sbyte_0 = (sbyte)(left.register.sbyte_0 * right.register.sbyte_0);
+ product.register.sbyte_1 = (sbyte)(left.register.sbyte_1 * right.register.sbyte_1);
+ product.register.sbyte_2 = (sbyte)(left.register.sbyte_2 * right.register.sbyte_2);
+ product.register.sbyte_3 = (sbyte)(left.register.sbyte_3 * right.register.sbyte_3);
+ product.register.sbyte_4 = (sbyte)(left.register.sbyte_4 * right.register.sbyte_4);
+ product.register.sbyte_5 = (sbyte)(left.register.sbyte_5 * right.register.sbyte_5);
+ product.register.sbyte_6 = (sbyte)(left.register.sbyte_6 * right.register.sbyte_6);
+ product.register.sbyte_7 = (sbyte)(left.register.sbyte_7 * right.register.sbyte_7);
+ product.register.sbyte_8 = (sbyte)(left.register.sbyte_8 * right.register.sbyte_8);
+ product.register.sbyte_9 = (sbyte)(left.register.sbyte_9 * right.register.sbyte_9);
+ product.register.sbyte_10 = (sbyte)(left.register.sbyte_10 * right.register.sbyte_10);
+ product.register.sbyte_11 = (sbyte)(left.register.sbyte_11 * right.register.sbyte_11);
+ product.register.sbyte_12 = (sbyte)(left.register.sbyte_12 * right.register.sbyte_12);
+ product.register.sbyte_13 = (sbyte)(left.register.sbyte_13 * right.register.sbyte_13);
+ product.register.sbyte_14 = (sbyte)(left.register.sbyte_14 * right.register.sbyte_14);
+ product.register.sbyte_15 = (sbyte)(left.register.sbyte_15 * right.register.sbyte_15);
+ }
+ else if (typeof(T) == typeof(ushort))
+ {
+ product.register.uint16_0 = (ushort)(left.register.uint16_0 * right.register.uint16_0);
+ product.register.uint16_1 = (ushort)(left.register.uint16_1 * right.register.uint16_1);
+ product.register.uint16_2 = (ushort)(left.register.uint16_2 * right.register.uint16_2);
+ product.register.uint16_3 = (ushort)(left.register.uint16_3 * right.register.uint16_3);
+ product.register.uint16_4 = (ushort)(left.register.uint16_4 * right.register.uint16_4);
+ product.register.uint16_5 = (ushort)(left.register.uint16_5 * right.register.uint16_5);
+ product.register.uint16_6 = (ushort)(left.register.uint16_6 * right.register.uint16_6);
+ product.register.uint16_7 = (ushort)(left.register.uint16_7 * right.register.uint16_7);
+ }
+ else if (typeof(T) == typeof(short))
+ {
+ product.register.int16_0 = (short)(left.register.int16_0 * right.register.int16_0);
+ product.register.int16_1 = (short)(left.register.int16_1 * right.register.int16_1);
+ product.register.int16_2 = (short)(left.register.int16_2 * right.register.int16_2);
+ product.register.int16_3 = (short)(left.register.int16_3 * right.register.int16_3);
+ product.register.int16_4 = (short)(left.register.int16_4 * right.register.int16_4);
+ product.register.int16_5 = (short)(left.register.int16_5 * right.register.int16_5);
+ product.register.int16_6 = (short)(left.register.int16_6 * right.register.int16_6);
+ product.register.int16_7 = (short)(left.register.int16_7 * right.register.int16_7);
+ }
+ else if (typeof(T) == typeof(uint))
+ {
+ product.register.uint32_0 = (uint)(left.register.uint32_0 * right.register.uint32_0);
+ product.register.uint32_1 = (uint)(left.register.uint32_1 * right.register.uint32_1);
+ product.register.uint32_2 = (uint)(left.register.uint32_2 * right.register.uint32_2);
+ product.register.uint32_3 = (uint)(left.register.uint32_3 * right.register.uint32_3);
+ }
+ else if (typeof(T) == typeof(int))
+ {
+ product.register.int32_0 = (int)(left.register.int32_0 * right.register.int32_0);
+ product.register.int32_1 = (int)(left.register.int32_1 * right.register.int32_1);
+ product.register.int32_2 = (int)(left.register.int32_2 * right.register.int32_2);
+ product.register.int32_3 = (int)(left.register.int32_3 * right.register.int32_3);
+ }
+ else if (typeof(T) == typeof(ulong))
+ {
+ product.register.uint64_0 = (ulong)(left.register.uint64_0 * right.register.uint64_0);
+ product.register.uint64_1 = (ulong)(left.register.uint64_1 * right.register.uint64_1);
+ }
+ else if (typeof(T) == typeof(long))
+ {
+ product.register.int64_0 = (long)(left.register.int64_0 * right.register.int64_0);
+ product.register.int64_1 = (long)(left.register.int64_1 * right.register.int64_1);
+ }
+ else if (typeof(T) == typeof(float))
+ {
+ product.register.single_0 = (float)(left.register.single_0 * right.register.single_0);
+ product.register.single_1 = (float)(left.register.single_1 * right.register.single_1);
+ product.register.single_2 = (float)(left.register.single_2 * right.register.single_2);
+ product.register.single_3 = (float)(left.register.single_3 * right.register.single_3);
+ }
+ else if (typeof(T) == typeof(double))
+ {
+ product.register.double_0 = (double)(left.register.double_0 * right.register.double_0);
+ product.register.double_1 = (double)(left.register.double_1 * right.register.double_1);
}
return product;
}
else
{
Vector<T> product = new Vector<T>();
- if (typeof(T) == typeof(Byte))
- {
- product.register.byte_0 = (Byte)(value.register.byte_0 * (Byte)(object)factor);
- product.register.byte_1 = (Byte)(value.register.byte_1 * (Byte)(object)factor);
- product.register.byte_2 = (Byte)(value.register.byte_2 * (Byte)(object)factor);
- product.register.byte_3 = (Byte)(value.register.byte_3 * (Byte)(object)factor);
- product.register.byte_4 = (Byte)(value.register.byte_4 * (Byte)(object)factor);
- product.register.byte_5 = (Byte)(value.register.byte_5 * (Byte)(object)factor);
- product.register.byte_6 = (Byte)(value.register.byte_6 * (Byte)(object)factor);
- product.register.byte_7 = (Byte)(value.register.byte_7 * (Byte)(object)factor);
- product.register.byte_8 = (Byte)(value.register.byte_8 * (Byte)(object)factor);
- product.register.byte_9 = (Byte)(value.register.byte_9 * (Byte)(object)factor);
- product.register.byte_10 = (Byte)(value.register.byte_10 * (Byte)(object)factor);
- product.register.byte_11 = (Byte)(value.register.byte_11 * (Byte)(object)factor);
- product.register.byte_12 = (Byte)(value.register.byte_12 * (Byte)(object)factor);
- product.register.byte_13 = (Byte)(value.register.byte_13 * (Byte)(object)factor);
- product.register.byte_14 = (Byte)(value.register.byte_14 * (Byte)(object)factor);
- product.register.byte_15 = (Byte)(value.register.byte_15 * (Byte)(object)factor);
- }
- else if (typeof(T) == typeof(SByte))
- {
- product.register.sbyte_0 = (SByte)(value.register.sbyte_0 * (SByte)(object)factor);
- product.register.sbyte_1 = (SByte)(value.register.sbyte_1 * (SByte)(object)factor);
- product.register.sbyte_2 = (SByte)(value.register.sbyte_2 * (SByte)(object)factor);
- product.register.sbyte_3 = (SByte)(value.register.sbyte_3 * (SByte)(object)factor);
- product.register.sbyte_4 = (SByte)(value.register.sbyte_4 * (SByte)(object)factor);
- product.register.sbyte_5 = (SByte)(value.register.sbyte_5 * (SByte)(object)factor);
- product.register.sbyte_6 = (SByte)(value.register.sbyte_6 * (SByte)(object)factor);
- product.register.sbyte_7 = (SByte)(value.register.sbyte_7 * (SByte)(object)factor);
- product.register.sbyte_8 = (SByte)(value.register.sbyte_8 * (SByte)(object)factor);
- product.register.sbyte_9 = (SByte)(value.register.sbyte_9 * (SByte)(object)factor);
- product.register.sbyte_10 = (SByte)(value.register.sbyte_10 * (SByte)(object)factor);
- product.register.sbyte_11 = (SByte)(value.register.sbyte_11 * (SByte)(object)factor);
- product.register.sbyte_12 = (SByte)(value.register.sbyte_12 * (SByte)(object)factor);
- product.register.sbyte_13 = (SByte)(value.register.sbyte_13 * (SByte)(object)factor);
- product.register.sbyte_14 = (SByte)(value.register.sbyte_14 * (SByte)(object)factor);
- product.register.sbyte_15 = (SByte)(value.register.sbyte_15 * (SByte)(object)factor);
- }
- else if (typeof(T) == typeof(UInt16))
- {
- product.register.uint16_0 = (UInt16)(value.register.uint16_0 * (UInt16)(object)factor);
- product.register.uint16_1 = (UInt16)(value.register.uint16_1 * (UInt16)(object)factor);
- product.register.uint16_2 = (UInt16)(value.register.uint16_2 * (UInt16)(object)factor);
- product.register.uint16_3 = (UInt16)(value.register.uint16_3 * (UInt16)(object)factor);
- product.register.uint16_4 = (UInt16)(value.register.uint16_4 * (UInt16)(object)factor);
- product.register.uint16_5 = (UInt16)(value.register.uint16_5 * (UInt16)(object)factor);
- product.register.uint16_6 = (UInt16)(value.register.uint16_6 * (UInt16)(object)factor);
- product.register.uint16_7 = (UInt16)(value.register.uint16_7 * (UInt16)(object)factor);
- }
- else if (typeof(T) == typeof(Int16))
- {
- product.register.int16_0 = (Int16)(value.register.int16_0 * (Int16)(object)factor);
- product.register.int16_1 = (Int16)(value.register.int16_1 * (Int16)(object)factor);
- product.register.int16_2 = (Int16)(value.register.int16_2 * (Int16)(object)factor);
- product.register.int16_3 = (Int16)(value.register.int16_3 * (Int16)(object)factor);
- product.register.int16_4 = (Int16)(value.register.int16_4 * (Int16)(object)factor);
- product.register.int16_5 = (Int16)(value.register.int16_5 * (Int16)(object)factor);
- product.register.int16_6 = (Int16)(value.register.int16_6 * (Int16)(object)factor);
- product.register.int16_7 = (Int16)(value.register.int16_7 * (Int16)(object)factor);
- }
- else if (typeof(T) == typeof(UInt32))
- {
- product.register.uint32_0 = (UInt32)(value.register.uint32_0 * (UInt32)(object)factor);
- product.register.uint32_1 = (UInt32)(value.register.uint32_1 * (UInt32)(object)factor);
- product.register.uint32_2 = (UInt32)(value.register.uint32_2 * (UInt32)(object)factor);
- product.register.uint32_3 = (UInt32)(value.register.uint32_3 * (UInt32)(object)factor);
- }
- else if (typeof(T) == typeof(Int32))
- {
- product.register.int32_0 = (Int32)(value.register.int32_0 * (Int32)(object)factor);
- product.register.int32_1 = (Int32)(value.register.int32_1 * (Int32)(object)factor);
- product.register.int32_2 = (Int32)(value.register.int32_2 * (Int32)(object)factor);
- product.register.int32_3 = (Int32)(value.register.int32_3 * (Int32)(object)factor);
- }
- else if (typeof(T) == typeof(UInt64))
- {
- product.register.uint64_0 = (UInt64)(value.register.uint64_0 * (UInt64)(object)factor);
- product.register.uint64_1 = (UInt64)(value.register.uint64_1 * (UInt64)(object)factor);
- }
- else if (typeof(T) == typeof(Int64))
- {
- product.register.int64_0 = (Int64)(value.register.int64_0 * (Int64)(object)factor);
- product.register.int64_1 = (Int64)(value.register.int64_1 * (Int64)(object)factor);
- }
- else if (typeof(T) == typeof(Single))
- {
- product.register.single_0 = (Single)(value.register.single_0 * (Single)(object)factor);
- product.register.single_1 = (Single)(value.register.single_1 * (Single)(object)factor);
- product.register.single_2 = (Single)(value.register.single_2 * (Single)(object)factor);
- product.register.single_3 = (Single)(value.register.single_3 * (Single)(object)factor);
- }
- else if (typeof(T) == typeof(Double))
- {
- product.register.double_0 = (Double)(value.register.double_0 * (Double)(object)factor);
- product.register.double_1 = (Double)(value.register.double_1 * (Double)(object)factor);
+ if (typeof(T) == typeof(byte))
+ {
+ product.register.byte_0 = (byte)(value.register.byte_0 * (byte)(object)factor);
+ product.register.byte_1 = (byte)(value.register.byte_1 * (byte)(object)factor);
+ product.register.byte_2 = (byte)(value.register.byte_2 * (byte)(object)factor);
+ product.register.byte_3 = (byte)(value.register.byte_3 * (byte)(object)factor);
+ product.register.byte_4 = (byte)(value.register.byte_4 * (byte)(object)factor);
+ product.register.byte_5 = (byte)(value.register.byte_5 * (byte)(object)factor);
+ product.register.byte_6 = (byte)(value.register.byte_6 * (byte)(object)factor);
+ product.register.byte_7 = (byte)(value.register.byte_7 * (byte)(object)factor);
+ product.register.byte_8 = (byte)(value.register.byte_8 * (byte)(object)factor);
+ product.register.byte_9 = (byte)(value.register.byte_9 * (byte)(object)factor);
+ product.register.byte_10 = (byte)(value.register.byte_10 * (byte)(object)factor);
+ product.register.byte_11 = (byte)(value.register.byte_11 * (byte)(object)factor);
+ product.register.byte_12 = (byte)(value.register.byte_12 * (byte)(object)factor);
+ product.register.byte_13 = (byte)(value.register.byte_13 * (byte)(object)factor);
+ product.register.byte_14 = (byte)(value.register.byte_14 * (byte)(object)factor);
+ product.register.byte_15 = (byte)(value.register.byte_15 * (byte)(object)factor);
+ }
+ else if (typeof(T) == typeof(sbyte))
+ {
+ product.register.sbyte_0 = (sbyte)(value.register.sbyte_0 * (sbyte)(object)factor);
+ product.register.sbyte_1 = (sbyte)(value.register.sbyte_1 * (sbyte)(object)factor);
+ product.register.sbyte_2 = (sbyte)(value.register.sbyte_2 * (sbyte)(object)factor);
+ product.register.sbyte_3 = (sbyte)(value.register.sbyte_3 * (sbyte)(object)factor);
+ product.register.sbyte_4 = (sbyte)(value.register.sbyte_4 * (sbyte)(object)factor);
+ product.register.sbyte_5 = (sbyte)(value.register.sbyte_5 * (sbyte)(object)factor);
+ product.register.sbyte_6 = (sbyte)(value.register.sbyte_6 * (sbyte)(object)factor);
+ product.register.sbyte_7 = (sbyte)(value.register.sbyte_7 * (sbyte)(object)factor);
+ product.register.sbyte_8 = (sbyte)(value.register.sbyte_8 * (sbyte)(object)factor);
+ product.register.sbyte_9 = (sbyte)(value.register.sbyte_9 * (sbyte)(object)factor);
+ product.register.sbyte_10 = (sbyte)(value.register.sbyte_10 * (sbyte)(object)factor);
+ product.register.sbyte_11 = (sbyte)(value.register.sbyte_11 * (sbyte)(object)factor);
+ product.register.sbyte_12 = (sbyte)(value.register.sbyte_12 * (sbyte)(object)factor);
+ product.register.sbyte_13 = (sbyte)(value.register.sbyte_13 * (sbyte)(object)factor);
+ product.register.sbyte_14 = (sbyte)(value.register.sbyte_14 * (sbyte)(object)factor);
+ product.register.sbyte_15 = (sbyte)(value.register.sbyte_15 * (sbyte)(object)factor);
+ }
+ else if (typeof(T) == typeof(ushort))
+ {
+ product.register.uint16_0 = (ushort)(value.register.uint16_0 * (ushort)(object)factor);
+ product.register.uint16_1 = (ushort)(value.register.uint16_1 * (ushort)(object)factor);
+ product.register.uint16_2 = (ushort)(value.register.uint16_2 * (ushort)(object)factor);
+ product.register.uint16_3 = (ushort)(value.register.uint16_3 * (ushort)(object)factor);
+ product.register.uint16_4 = (ushort)(value.register.uint16_4 * (ushort)(object)factor);
+ product.register.uint16_5 = (ushort)(value.register.uint16_5 * (ushort)(object)factor);
+ product.register.uint16_6 = (ushort)(value.register.uint16_6 * (ushort)(object)factor);
+ product.register.uint16_7 = (ushort)(value.register.uint16_7 * (ushort)(object)factor);
+ }
+ else if (typeof(T) == typeof(short))
+ {
+ product.register.int16_0 = (short)(value.register.int16_0 * (short)(object)factor);
+ product.register.int16_1 = (short)(value.register.int16_1 * (short)(object)factor);
+ product.register.int16_2 = (short)(value.register.int16_2 * (short)(object)factor);
+ product.register.int16_3 = (short)(value.register.int16_3 * (short)(object)factor);
+ product.register.int16_4 = (short)(value.register.int16_4 * (short)(object)factor);
+ product.register.int16_5 = (short)(value.register.int16_5 * (short)(object)factor);
+ product.register.int16_6 = (short)(value.register.int16_6 * (short)(object)factor);
+ product.register.int16_7 = (short)(value.register.int16_7 * (short)(object)factor);
+ }
+ else if (typeof(T) == typeof(uint))
+ {
+ product.register.uint32_0 = (uint)(value.register.uint32_0 * (uint)(object)factor);
+ product.register.uint32_1 = (uint)(value.register.uint32_1 * (uint)(object)factor);
+ product.register.uint32_2 = (uint)(value.register.uint32_2 * (uint)(object)factor);
+ product.register.uint32_3 = (uint)(value.register.uint32_3 * (uint)(object)factor);
+ }
+ else if (typeof(T) == typeof(int))
+ {
+ product.register.int32_0 = (int)(value.register.int32_0 * (int)(object)factor);
+ product.register.int32_1 = (int)(value.register.int32_1 * (int)(object)factor);
+ product.register.int32_2 = (int)(value.register.int32_2 * (int)(object)factor);
+ product.register.int32_3 = (int)(value.register.int32_3 * (int)(object)factor);
+ }
+ else if (typeof(T) == typeof(ulong))
+ {
+ product.register.uint64_0 = (ulong)(value.register.uint64_0 * (ulong)(object)factor);
+ product.register.uint64_1 = (ulong)(value.register.uint64_1 * (ulong)(object)factor);
+ }
+ else if (typeof(T) == typeof(long))
+ {
+ product.register.int64_0 = (long)(value.register.int64_0 * (long)(object)factor);
+ product.register.int64_1 = (long)(value.register.int64_1 * (long)(object)factor);
+ }
+ else if (typeof(T) == typeof(float))
+ {
+ product.register.single_0 = (float)(value.register.single_0 * (float)(object)factor);
+ product.register.single_1 = (float)(value.register.single_1 * (float)(object)factor);
+ product.register.single_2 = (float)(value.register.single_2 * (float)(object)factor);
+ product.register.single_3 = (float)(value.register.single_3 * (float)(object)factor);
+ }
+ else if (typeof(T) == typeof(double))
+ {
+ product.register.double_0 = (double)(value.register.double_0 * (double)(object)factor);
+ product.register.double_1 = (double)(value.register.double_1 * (double)(object)factor);
}
return product;
}
else
{
Vector<T> product = new Vector<T>();
- if (typeof(T) == typeof(Byte))
- {
- product.register.byte_0 = (Byte)(value.register.byte_0 * (Byte)(object)factor);
- product.register.byte_1 = (Byte)(value.register.byte_1 * (Byte)(object)factor);
- product.register.byte_2 = (Byte)(value.register.byte_2 * (Byte)(object)factor);
- product.register.byte_3 = (Byte)(value.register.byte_3 * (Byte)(object)factor);
- product.register.byte_4 = (Byte)(value.register.byte_4 * (Byte)(object)factor);
- product.register.byte_5 = (Byte)(value.register.byte_5 * (Byte)(object)factor);
- product.register.byte_6 = (Byte)(value.register.byte_6 * (Byte)(object)factor);
- product.register.byte_7 = (Byte)(value.register.byte_7 * (Byte)(object)factor);
- product.register.byte_8 = (Byte)(value.register.byte_8 * (Byte)(object)factor);
- product.register.byte_9 = (Byte)(value.register.byte_9 * (Byte)(object)factor);
- product.register.byte_10 = (Byte)(value.register.byte_10 * (Byte)(object)factor);
- product.register.byte_11 = (Byte)(value.register.byte_11 * (Byte)(object)factor);
- product.register.byte_12 = (Byte)(value.register.byte_12 * (Byte)(object)factor);
- product.register.byte_13 = (Byte)(value.register.byte_13 * (Byte)(object)factor);
- product.register.byte_14 = (Byte)(value.register.byte_14 * (Byte)(object)factor);
- product.register.byte_15 = (Byte)(value.register.byte_15 * (Byte)(object)factor);
- }
- else if (typeof(T) == typeof(SByte))
- {
- product.register.sbyte_0 = (SByte)(value.register.sbyte_0 * (SByte)(object)factor);
- product.register.sbyte_1 = (SByte)(value.register.sbyte_1 * (SByte)(object)factor);
- product.register.sbyte_2 = (SByte)(value.register.sbyte_2 * (SByte)(object)factor);
- product.register.sbyte_3 = (SByte)(value.register.sbyte_3 * (SByte)(object)factor);
- product.register.sbyte_4 = (SByte)(value.register.sbyte_4 * (SByte)(object)factor);
- product.register.sbyte_5 = (SByte)(value.register.sbyte_5 * (SByte)(object)factor);
- product.register.sbyte_6 = (SByte)(value.register.sbyte_6 * (SByte)(object)factor);
- product.register.sbyte_7 = (SByte)(value.register.sbyte_7 * (SByte)(object)factor);
- product.register.sbyte_8 = (SByte)(value.register.sbyte_8 * (SByte)(object)factor);
- product.register.sbyte_9 = (SByte)(value.register.sbyte_9 * (SByte)(object)factor);
- product.register.sbyte_10 = (SByte)(value.register.sbyte_10 * (SByte)(object)factor);
- product.register.sbyte_11 = (SByte)(value.register.sbyte_11 * (SByte)(object)factor);
- product.register.sbyte_12 = (SByte)(value.register.sbyte_12 * (SByte)(object)factor);
- product.register.sbyte_13 = (SByte)(value.register.sbyte_13 * (SByte)(object)factor);
- product.register.sbyte_14 = (SByte)(value.register.sbyte_14 * (SByte)(object)factor);
- product.register.sbyte_15 = (SByte)(value.register.sbyte_15 * (SByte)(object)factor);
- }
- else if (typeof(T) == typeof(UInt16))
- {
- product.register.uint16_0 = (UInt16)(value.register.uint16_0 * (UInt16)(object)factor);
- product.register.uint16_1 = (UInt16)(value.register.uint16_1 * (UInt16)(object)factor);
- product.register.uint16_2 = (UInt16)(value.register.uint16_2 * (UInt16)(object)factor);
- product.register.uint16_3 = (UInt16)(value.register.uint16_3 * (UInt16)(object)factor);
- product.register.uint16_4 = (UInt16)(value.register.uint16_4 * (UInt16)(object)factor);
- product.register.uint16_5 = (UInt16)(value.register.uint16_5 * (UInt16)(object)factor);
- product.register.uint16_6 = (UInt16)(value.register.uint16_6 * (UInt16)(object)factor);
- product.register.uint16_7 = (UInt16)(value.register.uint16_7 * (UInt16)(object)factor);
- }
- else if (typeof(T) == typeof(Int16))
- {
- product.register.int16_0 = (Int16)(value.register.int16_0 * (Int16)(object)factor);
- product.register.int16_1 = (Int16)(value.register.int16_1 * (Int16)(object)factor);
- product.register.int16_2 = (Int16)(value.register.int16_2 * (Int16)(object)factor);
- product.register.int16_3 = (Int16)(value.register.int16_3 * (Int16)(object)factor);
- product.register.int16_4 = (Int16)(value.register.int16_4 * (Int16)(object)factor);
- product.register.int16_5 = (Int16)(value.register.int16_5 * (Int16)(object)factor);
- product.register.int16_6 = (Int16)(value.register.int16_6 * (Int16)(object)factor);
- product.register.int16_7 = (Int16)(value.register.int16_7 * (Int16)(object)factor);
- }
- else if (typeof(T) == typeof(UInt32))
- {
- product.register.uint32_0 = (UInt32)(value.register.uint32_0 * (UInt32)(object)factor);
- product.register.uint32_1 = (UInt32)(value.register.uint32_1 * (UInt32)(object)factor);
- product.register.uint32_2 = (UInt32)(value.register.uint32_2 * (UInt32)(object)factor);
- product.register.uint32_3 = (UInt32)(value.register.uint32_3 * (UInt32)(object)factor);
- }
- else if (typeof(T) == typeof(Int32))
- {
- product.register.int32_0 = (Int32)(value.register.int32_0 * (Int32)(object)factor);
- product.register.int32_1 = (Int32)(value.register.int32_1 * (Int32)(object)factor);
- product.register.int32_2 = (Int32)(value.register.int32_2 * (Int32)(object)factor);
- product.register.int32_3 = (Int32)(value.register.int32_3 * (Int32)(object)factor);
- }
- else if (typeof(T) == typeof(UInt64))
- {
- product.register.uint64_0 = (UInt64)(value.register.uint64_0 * (UInt64)(object)factor);
- product.register.uint64_1 = (UInt64)(value.register.uint64_1 * (UInt64)(object)factor);
- }
- else if (typeof(T) == typeof(Int64))
- {
- product.register.int64_0 = (Int64)(value.register.int64_0 * (Int64)(object)factor);
- product.register.int64_1 = (Int64)(value.register.int64_1 * (Int64)(object)factor);
- }
- else if (typeof(T) == typeof(Single))
- {
- product.register.single_0 = (Single)(value.register.single_0 * (Single)(object)factor);
- product.register.single_1 = (Single)(value.register.single_1 * (Single)(object)factor);
- product.register.single_2 = (Single)(value.register.single_2 * (Single)(object)factor);
- product.register.single_3 = (Single)(value.register.single_3 * (Single)(object)factor);
- }
- else if (typeof(T) == typeof(Double))
- {
- product.register.double_0 = (Double)(value.register.double_0 * (Double)(object)factor);
- product.register.double_1 = (Double)(value.register.double_1 * (Double)(object)factor);
+ if (typeof(T) == typeof(byte))
+ {
+ product.register.byte_0 = (byte)(value.register.byte_0 * (byte)(object)factor);
+ product.register.byte_1 = (byte)(value.register.byte_1 * (byte)(object)factor);
+ product.register.byte_2 = (byte)(value.register.byte_2 * (byte)(object)factor);
+ product.register.byte_3 = (byte)(value.register.byte_3 * (byte)(object)factor);
+ product.register.byte_4 = (byte)(value.register.byte_4 * (byte)(object)factor);
+ product.register.byte_5 = (byte)(value.register.byte_5 * (byte)(object)factor);
+ product.register.byte_6 = (byte)(value.register.byte_6 * (byte)(object)factor);
+ product.register.byte_7 = (byte)(value.register.byte_7 * (byte)(object)factor);
+ product.register.byte_8 = (byte)(value.register.byte_8 * (byte)(object)factor);
+ product.register.byte_9 = (byte)(value.register.byte_9 * (byte)(object)factor);
+ product.register.byte_10 = (byte)(value.register.byte_10 * (byte)(object)factor);
+ product.register.byte_11 = (byte)(value.register.byte_11 * (byte)(object)factor);
+ product.register.byte_12 = (byte)(value.register.byte_12 * (byte)(object)factor);
+ product.register.byte_13 = (byte)(value.register.byte_13 * (byte)(object)factor);
+ product.register.byte_14 = (byte)(value.register.byte_14 * (byte)(object)factor);
+ product.register.byte_15 = (byte)(value.register.byte_15 * (byte)(object)factor);
+ }
+ else if (typeof(T) == typeof(sbyte))
+ {
+ product.register.sbyte_0 = (sbyte)(value.register.sbyte_0 * (sbyte)(object)factor);
+ product.register.sbyte_1 = (sbyte)(value.register.sbyte_1 * (sbyte)(object)factor);
+ product.register.sbyte_2 = (sbyte)(value.register.sbyte_2 * (sbyte)(object)factor);
+ product.register.sbyte_3 = (sbyte)(value.register.sbyte_3 * (sbyte)(object)factor);
+ product.register.sbyte_4 = (sbyte)(value.register.sbyte_4 * (sbyte)(object)factor);
+ product.register.sbyte_5 = (sbyte)(value.register.sbyte_5 * (sbyte)(object)factor);
+ product.register.sbyte_6 = (sbyte)(value.register.sbyte_6 * (sbyte)(object)factor);
+ product.register.sbyte_7 = (sbyte)(value.register.sbyte_7 * (sbyte)(object)factor);
+ product.register.sbyte_8 = (sbyte)(value.register.sbyte_8 * (sbyte)(object)factor);
+ product.register.sbyte_9 = (sbyte)(value.register.sbyte_9 * (sbyte)(object)factor);
+ product.register.sbyte_10 = (sbyte)(value.register.sbyte_10 * (sbyte)(object)factor);
+ product.register.sbyte_11 = (sbyte)(value.register.sbyte_11 * (sbyte)(object)factor);
+ product.register.sbyte_12 = (sbyte)(value.register.sbyte_12 * (sbyte)(object)factor);
+ product.register.sbyte_13 = (sbyte)(value.register.sbyte_13 * (sbyte)(object)factor);
+ product.register.sbyte_14 = (sbyte)(value.register.sbyte_14 * (sbyte)(object)factor);
+ product.register.sbyte_15 = (sbyte)(value.register.sbyte_15 * (sbyte)(object)factor);
+ }
+ else if (typeof(T) == typeof(ushort))
+ {
+ product.register.uint16_0 = (ushort)(value.register.uint16_0 * (ushort)(object)factor);
+ product.register.uint16_1 = (ushort)(value.register.uint16_1 * (ushort)(object)factor);
+ product.register.uint16_2 = (ushort)(value.register.uint16_2 * (ushort)(object)factor);
+ product.register.uint16_3 = (ushort)(value.register.uint16_3 * (ushort)(object)factor);
+ product.register.uint16_4 = (ushort)(value.register.uint16_4 * (ushort)(object)factor);
+ product.register.uint16_5 = (ushort)(value.register.uint16_5 * (ushort)(object)factor);
+ product.register.uint16_6 = (ushort)(value.register.uint16_6 * (ushort)(object)factor);
+ product.register.uint16_7 = (ushort)(value.register.uint16_7 * (ushort)(object)factor);
+ }
+ else if (typeof(T) == typeof(short))
+ {
+ product.register.int16_0 = (short)(value.register.int16_0 * (short)(object)factor);
+ product.register.int16_1 = (short)(value.register.int16_1 * (short)(object)factor);
+ product.register.int16_2 = (short)(value.register.int16_2 * (short)(object)factor);
+ product.register.int16_3 = (short)(value.register.int16_3 * (short)(object)factor);
+ product.register.int16_4 = (short)(value.register.int16_4 * (short)(object)factor);
+ product.register.int16_5 = (short)(value.register.int16_5 * (short)(object)factor);
+ product.register.int16_6 = (short)(value.register.int16_6 * (short)(object)factor);
+ product.register.int16_7 = (short)(value.register.int16_7 * (short)(object)factor);
+ }
+ else if (typeof(T) == typeof(uint))
+ {
+ product.register.uint32_0 = (uint)(value.register.uint32_0 * (uint)(object)factor);
+ product.register.uint32_1 = (uint)(value.register.uint32_1 * (uint)(object)factor);
+ product.register.uint32_2 = (uint)(value.register.uint32_2 * (uint)(object)factor);
+ product.register.uint32_3 = (uint)(value.register.uint32_3 * (uint)(object)factor);
+ }
+ else if (typeof(T) == typeof(int))
+ {
+ product.register.int32_0 = (int)(value.register.int32_0 * (int)(object)factor);
+ product.register.int32_1 = (int)(value.register.int32_1 * (int)(object)factor);
+ product.register.int32_2 = (int)(value.register.int32_2 * (int)(object)factor);
+ product.register.int32_3 = (int)(value.register.int32_3 * (int)(object)factor);
+ }
+ else if (typeof(T) == typeof(ulong))
+ {
+ product.register.uint64_0 = (ulong)(value.register.uint64_0 * (ulong)(object)factor);
+ product.register.uint64_1 = (ulong)(value.register.uint64_1 * (ulong)(object)factor);
+ }
+ else if (typeof(T) == typeof(long))
+ {
+ product.register.int64_0 = (long)(value.register.int64_0 * (long)(object)factor);
+ product.register.int64_1 = (long)(value.register.int64_1 * (long)(object)factor);
+ }
+ else if (typeof(T) == typeof(float))
+ {
+ product.register.single_0 = (float)(value.register.single_0 * (float)(object)factor);
+ product.register.single_1 = (float)(value.register.single_1 * (float)(object)factor);
+ product.register.single_2 = (float)(value.register.single_2 * (float)(object)factor);
+ product.register.single_3 = (float)(value.register.single_3 * (float)(object)factor);
+ }
+ else if (typeof(T) == typeof(double))
+ {
+ product.register.double_0 = (double)(value.register.double_0 * (double)(object)factor);
+ product.register.double_1 = (double)(value.register.double_1 * (double)(object)factor);
}
return product;
}
{
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- Byte* dataPtr = stackalloc Byte[Count];
+ byte* dataPtr = stackalloc byte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Byte)(object)ScalarDivide(left[g], right[g]);
+ dataPtr[g] = (byte)(object)ScalarDivide(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- SByte* dataPtr = stackalloc SByte[Count];
+ sbyte* dataPtr = stackalloc sbyte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (SByte)(object)ScalarDivide(left[g], right[g]);
+ dataPtr[g] = (sbyte)(object)ScalarDivide(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- UInt16* dataPtr = stackalloc UInt16[Count];
+ ushort* dataPtr = stackalloc ushort[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (UInt16)(object)ScalarDivide(left[g], right[g]);
+ dataPtr[g] = (ushort)(object)ScalarDivide(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16* dataPtr = stackalloc Int16[Count];
+ short* dataPtr = stackalloc short[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int16)(object)ScalarDivide(left[g], right[g]);
+ dataPtr[g] = (short)(object)ScalarDivide(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32* dataPtr = stackalloc UInt32[Count];
+ uint* dataPtr = stackalloc uint[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (UInt32)(object)ScalarDivide(left[g], right[g]);
+ dataPtr[g] = (uint)(object)ScalarDivide(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32* dataPtr = stackalloc Int32[Count];
+ int* dataPtr = stackalloc int[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int32)(object)ScalarDivide(left[g], right[g]);
+ dataPtr[g] = (int)(object)ScalarDivide(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64* dataPtr = stackalloc UInt64[Count];
+ ulong* dataPtr = stackalloc ulong[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (UInt64)(object)ScalarDivide(left[g], right[g]);
+ dataPtr[g] = (ulong)(object)ScalarDivide(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64* dataPtr = stackalloc Int64[Count];
+ long* dataPtr = stackalloc long[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int64)(object)ScalarDivide(left[g], right[g]);
+ dataPtr[g] = (long)(object)ScalarDivide(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single* dataPtr = stackalloc Single[Count];
+ float* dataPtr = stackalloc float[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Single)(object)ScalarDivide(left[g], right[g]);
+ dataPtr[g] = (float)(object)ScalarDivide(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double* dataPtr = stackalloc Double[Count];
+ double* dataPtr = stackalloc double[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Double)(object)ScalarDivide(left[g], right[g]);
+ dataPtr[g] = (double)(object)ScalarDivide(left[g], right[g]);
}
return new Vector<T>(dataPtr);
}
else
{
Vector<T> quotient = new Vector<T>();
- if (typeof(T) == typeof(Byte))
- {
- quotient.register.byte_0 = (Byte)(left.register.byte_0 / right.register.byte_0);
- quotient.register.byte_1 = (Byte)(left.register.byte_1 / right.register.byte_1);
- quotient.register.byte_2 = (Byte)(left.register.byte_2 / right.register.byte_2);
- quotient.register.byte_3 = (Byte)(left.register.byte_3 / right.register.byte_3);
- quotient.register.byte_4 = (Byte)(left.register.byte_4 / right.register.byte_4);
- quotient.register.byte_5 = (Byte)(left.register.byte_5 / right.register.byte_5);
- quotient.register.byte_6 = (Byte)(left.register.byte_6 / right.register.byte_6);
- quotient.register.byte_7 = (Byte)(left.register.byte_7 / right.register.byte_7);
- quotient.register.byte_8 = (Byte)(left.register.byte_8 / right.register.byte_8);
- quotient.register.byte_9 = (Byte)(left.register.byte_9 / right.register.byte_9);
- quotient.register.byte_10 = (Byte)(left.register.byte_10 / right.register.byte_10);
- quotient.register.byte_11 = (Byte)(left.register.byte_11 / right.register.byte_11);
- quotient.register.byte_12 = (Byte)(left.register.byte_12 / right.register.byte_12);
- quotient.register.byte_13 = (Byte)(left.register.byte_13 / right.register.byte_13);
- quotient.register.byte_14 = (Byte)(left.register.byte_14 / right.register.byte_14);
- quotient.register.byte_15 = (Byte)(left.register.byte_15 / right.register.byte_15);
- }
- else if (typeof(T) == typeof(SByte))
- {
- quotient.register.sbyte_0 = (SByte)(left.register.sbyte_0 / right.register.sbyte_0);
- quotient.register.sbyte_1 = (SByte)(left.register.sbyte_1 / right.register.sbyte_1);
- quotient.register.sbyte_2 = (SByte)(left.register.sbyte_2 / right.register.sbyte_2);
- quotient.register.sbyte_3 = (SByte)(left.register.sbyte_3 / right.register.sbyte_3);
- quotient.register.sbyte_4 = (SByte)(left.register.sbyte_4 / right.register.sbyte_4);
- quotient.register.sbyte_5 = (SByte)(left.register.sbyte_5 / right.register.sbyte_5);
- quotient.register.sbyte_6 = (SByte)(left.register.sbyte_6 / right.register.sbyte_6);
- quotient.register.sbyte_7 = (SByte)(left.register.sbyte_7 / right.register.sbyte_7);
- quotient.register.sbyte_8 = (SByte)(left.register.sbyte_8 / right.register.sbyte_8);
- quotient.register.sbyte_9 = (SByte)(left.register.sbyte_9 / right.register.sbyte_9);
- quotient.register.sbyte_10 = (SByte)(left.register.sbyte_10 / right.register.sbyte_10);
- quotient.register.sbyte_11 = (SByte)(left.register.sbyte_11 / right.register.sbyte_11);
- quotient.register.sbyte_12 = (SByte)(left.register.sbyte_12 / right.register.sbyte_12);
- quotient.register.sbyte_13 = (SByte)(left.register.sbyte_13 / right.register.sbyte_13);
- quotient.register.sbyte_14 = (SByte)(left.register.sbyte_14 / right.register.sbyte_14);
- quotient.register.sbyte_15 = (SByte)(left.register.sbyte_15 / right.register.sbyte_15);
- }
- else if (typeof(T) == typeof(UInt16))
- {
- quotient.register.uint16_0 = (UInt16)(left.register.uint16_0 / right.register.uint16_0);
- quotient.register.uint16_1 = (UInt16)(left.register.uint16_1 / right.register.uint16_1);
- quotient.register.uint16_2 = (UInt16)(left.register.uint16_2 / right.register.uint16_2);
- quotient.register.uint16_3 = (UInt16)(left.register.uint16_3 / right.register.uint16_3);
- quotient.register.uint16_4 = (UInt16)(left.register.uint16_4 / right.register.uint16_4);
- quotient.register.uint16_5 = (UInt16)(left.register.uint16_5 / right.register.uint16_5);
- quotient.register.uint16_6 = (UInt16)(left.register.uint16_6 / right.register.uint16_6);
- quotient.register.uint16_7 = (UInt16)(left.register.uint16_7 / right.register.uint16_7);
- }
- else if (typeof(T) == typeof(Int16))
- {
- quotient.register.int16_0 = (Int16)(left.register.int16_0 / right.register.int16_0);
- quotient.register.int16_1 = (Int16)(left.register.int16_1 / right.register.int16_1);
- quotient.register.int16_2 = (Int16)(left.register.int16_2 / right.register.int16_2);
- quotient.register.int16_3 = (Int16)(left.register.int16_3 / right.register.int16_3);
- quotient.register.int16_4 = (Int16)(left.register.int16_4 / right.register.int16_4);
- quotient.register.int16_5 = (Int16)(left.register.int16_5 / right.register.int16_5);
- quotient.register.int16_6 = (Int16)(left.register.int16_6 / right.register.int16_6);
- quotient.register.int16_7 = (Int16)(left.register.int16_7 / right.register.int16_7);
- }
- else if (typeof(T) == typeof(UInt32))
- {
- quotient.register.uint32_0 = (UInt32)(left.register.uint32_0 / right.register.uint32_0);
- quotient.register.uint32_1 = (UInt32)(left.register.uint32_1 / right.register.uint32_1);
- quotient.register.uint32_2 = (UInt32)(left.register.uint32_2 / right.register.uint32_2);
- quotient.register.uint32_3 = (UInt32)(left.register.uint32_3 / right.register.uint32_3);
- }
- else if (typeof(T) == typeof(Int32))
- {
- quotient.register.int32_0 = (Int32)(left.register.int32_0 / right.register.int32_0);
- quotient.register.int32_1 = (Int32)(left.register.int32_1 / right.register.int32_1);
- quotient.register.int32_2 = (Int32)(left.register.int32_2 / right.register.int32_2);
- quotient.register.int32_3 = (Int32)(left.register.int32_3 / right.register.int32_3);
- }
- else if (typeof(T) == typeof(UInt64))
- {
- quotient.register.uint64_0 = (UInt64)(left.register.uint64_0 / right.register.uint64_0);
- quotient.register.uint64_1 = (UInt64)(left.register.uint64_1 / right.register.uint64_1);
- }
- else if (typeof(T) == typeof(Int64))
- {
- quotient.register.int64_0 = (Int64)(left.register.int64_0 / right.register.int64_0);
- quotient.register.int64_1 = (Int64)(left.register.int64_1 / right.register.int64_1);
- }
- else if (typeof(T) == typeof(Single))
- {
- quotient.register.single_0 = (Single)(left.register.single_0 / right.register.single_0);
- quotient.register.single_1 = (Single)(left.register.single_1 / right.register.single_1);
- quotient.register.single_2 = (Single)(left.register.single_2 / right.register.single_2);
- quotient.register.single_3 = (Single)(left.register.single_3 / right.register.single_3);
- }
- else if (typeof(T) == typeof(Double))
- {
- quotient.register.double_0 = (Double)(left.register.double_0 / right.register.double_0);
- quotient.register.double_1 = (Double)(left.register.double_1 / right.register.double_1);
+ if (typeof(T) == typeof(byte))
+ {
+ quotient.register.byte_0 = (byte)(left.register.byte_0 / right.register.byte_0);
+ quotient.register.byte_1 = (byte)(left.register.byte_1 / right.register.byte_1);
+ quotient.register.byte_2 = (byte)(left.register.byte_2 / right.register.byte_2);
+ quotient.register.byte_3 = (byte)(left.register.byte_3 / right.register.byte_3);
+ quotient.register.byte_4 = (byte)(left.register.byte_4 / right.register.byte_4);
+ quotient.register.byte_5 = (byte)(left.register.byte_5 / right.register.byte_5);
+ quotient.register.byte_6 = (byte)(left.register.byte_6 / right.register.byte_6);
+ quotient.register.byte_7 = (byte)(left.register.byte_7 / right.register.byte_7);
+ quotient.register.byte_8 = (byte)(left.register.byte_8 / right.register.byte_8);
+ quotient.register.byte_9 = (byte)(left.register.byte_9 / right.register.byte_9);
+ quotient.register.byte_10 = (byte)(left.register.byte_10 / right.register.byte_10);
+ quotient.register.byte_11 = (byte)(left.register.byte_11 / right.register.byte_11);
+ quotient.register.byte_12 = (byte)(left.register.byte_12 / right.register.byte_12);
+ quotient.register.byte_13 = (byte)(left.register.byte_13 / right.register.byte_13);
+ quotient.register.byte_14 = (byte)(left.register.byte_14 / right.register.byte_14);
+ quotient.register.byte_15 = (byte)(left.register.byte_15 / right.register.byte_15);
+ }
+ else if (typeof(T) == typeof(sbyte))
+ {
+ quotient.register.sbyte_0 = (sbyte)(left.register.sbyte_0 / right.register.sbyte_0);
+ quotient.register.sbyte_1 = (sbyte)(left.register.sbyte_1 / right.register.sbyte_1);
+ quotient.register.sbyte_2 = (sbyte)(left.register.sbyte_2 / right.register.sbyte_2);
+ quotient.register.sbyte_3 = (sbyte)(left.register.sbyte_3 / right.register.sbyte_3);
+ quotient.register.sbyte_4 = (sbyte)(left.register.sbyte_4 / right.register.sbyte_4);
+ quotient.register.sbyte_5 = (sbyte)(left.register.sbyte_5 / right.register.sbyte_5);
+ quotient.register.sbyte_6 = (sbyte)(left.register.sbyte_6 / right.register.sbyte_6);
+ quotient.register.sbyte_7 = (sbyte)(left.register.sbyte_7 / right.register.sbyte_7);
+ quotient.register.sbyte_8 = (sbyte)(left.register.sbyte_8 / right.register.sbyte_8);
+ quotient.register.sbyte_9 = (sbyte)(left.register.sbyte_9 / right.register.sbyte_9);
+ quotient.register.sbyte_10 = (sbyte)(left.register.sbyte_10 / right.register.sbyte_10);
+ quotient.register.sbyte_11 = (sbyte)(left.register.sbyte_11 / right.register.sbyte_11);
+ quotient.register.sbyte_12 = (sbyte)(left.register.sbyte_12 / right.register.sbyte_12);
+ quotient.register.sbyte_13 = (sbyte)(left.register.sbyte_13 / right.register.sbyte_13);
+ quotient.register.sbyte_14 = (sbyte)(left.register.sbyte_14 / right.register.sbyte_14);
+ quotient.register.sbyte_15 = (sbyte)(left.register.sbyte_15 / right.register.sbyte_15);
+ }
+ else if (typeof(T) == typeof(ushort))
+ {
+ quotient.register.uint16_0 = (ushort)(left.register.uint16_0 / right.register.uint16_0);
+ quotient.register.uint16_1 = (ushort)(left.register.uint16_1 / right.register.uint16_1);
+ quotient.register.uint16_2 = (ushort)(left.register.uint16_2 / right.register.uint16_2);
+ quotient.register.uint16_3 = (ushort)(left.register.uint16_3 / right.register.uint16_3);
+ quotient.register.uint16_4 = (ushort)(left.register.uint16_4 / right.register.uint16_4);
+ quotient.register.uint16_5 = (ushort)(left.register.uint16_5 / right.register.uint16_5);
+ quotient.register.uint16_6 = (ushort)(left.register.uint16_6 / right.register.uint16_6);
+ quotient.register.uint16_7 = (ushort)(left.register.uint16_7 / right.register.uint16_7);
+ }
+ else if (typeof(T) == typeof(short))
+ {
+ quotient.register.int16_0 = (short)(left.register.int16_0 / right.register.int16_0);
+ quotient.register.int16_1 = (short)(left.register.int16_1 / right.register.int16_1);
+ quotient.register.int16_2 = (short)(left.register.int16_2 / right.register.int16_2);
+ quotient.register.int16_3 = (short)(left.register.int16_3 / right.register.int16_3);
+ quotient.register.int16_4 = (short)(left.register.int16_4 / right.register.int16_4);
+ quotient.register.int16_5 = (short)(left.register.int16_5 / right.register.int16_5);
+ quotient.register.int16_6 = (short)(left.register.int16_6 / right.register.int16_6);
+ quotient.register.int16_7 = (short)(left.register.int16_7 / right.register.int16_7);
+ }
+ else if (typeof(T) == typeof(uint))
+ {
+ quotient.register.uint32_0 = (uint)(left.register.uint32_0 / right.register.uint32_0);
+ quotient.register.uint32_1 = (uint)(left.register.uint32_1 / right.register.uint32_1);
+ quotient.register.uint32_2 = (uint)(left.register.uint32_2 / right.register.uint32_2);
+ quotient.register.uint32_3 = (uint)(left.register.uint32_3 / right.register.uint32_3);
+ }
+ else if (typeof(T) == typeof(int))
+ {
+ quotient.register.int32_0 = (int)(left.register.int32_0 / right.register.int32_0);
+ quotient.register.int32_1 = (int)(left.register.int32_1 / right.register.int32_1);
+ quotient.register.int32_2 = (int)(left.register.int32_2 / right.register.int32_2);
+ quotient.register.int32_3 = (int)(left.register.int32_3 / right.register.int32_3);
+ }
+ else if (typeof(T) == typeof(ulong))
+ {
+ quotient.register.uint64_0 = (ulong)(left.register.uint64_0 / right.register.uint64_0);
+ quotient.register.uint64_1 = (ulong)(left.register.uint64_1 / right.register.uint64_1);
+ }
+ else if (typeof(T) == typeof(long))
+ {
+ quotient.register.int64_0 = (long)(left.register.int64_0 / right.register.int64_0);
+ quotient.register.int64_1 = (long)(left.register.int64_1 / right.register.int64_1);
+ }
+ else if (typeof(T) == typeof(float))
+ {
+ quotient.register.single_0 = (float)(left.register.single_0 / right.register.single_0);
+ quotient.register.single_1 = (float)(left.register.single_1 / right.register.single_1);
+ quotient.register.single_2 = (float)(left.register.single_2 / right.register.single_2);
+ quotient.register.single_3 = (float)(left.register.single_3 / right.register.single_3);
+ }
+ else if (typeof(T) == typeof(double))
+ {
+ quotient.register.double_0 = (double)(left.register.double_0 / right.register.double_0);
+ quotient.register.double_1 = (double)(left.register.double_1 / right.register.double_1);
}
return quotient;
}
{
if (Vector.IsHardwareAccelerated)
{
- Int64* resultBase = &result.register.int64_0;
- Int64* leftBase = &left.register.int64_0;
- Int64* rightBase = &right.register.int64_0;
- for (int g = 0; g < Vector<Int64>.Count; g++)
+ long* resultBase = &result.register.int64_0;
+ long* leftBase = &left.register.int64_0;
+ long* rightBase = &right.register.int64_0;
+ for (int g = 0; g < Vector<long>.Count; g++)
{
resultBase[g] = leftBase[g] & rightBase[g];
}
{
if (Vector.IsHardwareAccelerated)
{
- Int64* resultBase = &result.register.int64_0;
- Int64* leftBase = &left.register.int64_0;
- Int64* rightBase = &right.register.int64_0;
- for (int g = 0; g < Vector<Int64>.Count; g++)
+ long* resultBase = &result.register.int64_0;
+ long* leftBase = &left.register.int64_0;
+ long* rightBase = &right.register.int64_0;
+ for (int g = 0; g < Vector<long>.Count; g++)
{
resultBase[g] = leftBase[g] | rightBase[g];
}
{
if (Vector.IsHardwareAccelerated)
{
- Int64* resultBase = &result.register.int64_0;
- Int64* leftBase = &left.register.int64_0;
- Int64* rightBase = &right.register.int64_0;
- for (int g = 0; g < Vector<Int64>.Count; g++)
+ long* resultBase = &result.register.int64_0;
+ long* leftBase = &left.register.int64_0;
+ long* rightBase = &right.register.int64_0;
+ for (int g = 0; g < Vector<long>.Count; g++)
{
resultBase[g] = leftBase[g] ^ rightBase[g];
}
/// <param name="value">The source vector</param>
/// <returns>The reinterpreted vector.</returns>
[Intrinsic]
- public static explicit operator Vector<Byte>(Vector<T> value)
+ public static explicit operator Vector<byte>(Vector<T> value)
{
- return new Vector<Byte>(ref value.register);
+ return new Vector<byte>(ref value.register);
}
/// <summary>
/// <returns>The reinterpreted vector.</returns>
[CLSCompliant(false)]
[Intrinsic]
- public static explicit operator Vector<SByte>(Vector<T> value)
+ public static explicit operator Vector<sbyte>(Vector<T> value)
{
- return new Vector<SByte>(ref value.register);
+ return new Vector<sbyte>(ref value.register);
}
/// <summary>
/// <returns>The reinterpreted vector.</returns>
[CLSCompliant(false)]
[Intrinsic]
- public static explicit operator Vector<UInt16>(Vector<T> value)
+ public static explicit operator Vector<ushort>(Vector<T> value)
{
- return new Vector<UInt16>(ref value.register);
+ return new Vector<ushort>(ref value.register);
}
/// <summary>
/// <param name="value">The source vector</param>
/// <returns>The reinterpreted vector.</returns>
[Intrinsic]
- public static explicit operator Vector<Int16>(Vector<T> value)
+ public static explicit operator Vector<short>(Vector<T> value)
{
- return new Vector<Int16>(ref value.register);
+ return new Vector<short>(ref value.register);
}
/// <summary>
/// <returns>The reinterpreted vector.</returns>
[CLSCompliant(false)]
[Intrinsic]
- public static explicit operator Vector<UInt32>(Vector<T> value)
+ public static explicit operator Vector<uint>(Vector<T> value)
{
- return new Vector<UInt32>(ref value.register);
+ return new Vector<uint>(ref value.register);
}
/// <summary>
/// <param name="value">The source vector</param>
/// <returns>The reinterpreted vector.</returns>
[Intrinsic]
- public static explicit operator Vector<Int32>(Vector<T> value)
+ public static explicit operator Vector<int>(Vector<T> value)
{
- return new Vector<Int32>(ref value.register);
+ return new Vector<int>(ref value.register);
}
/// <summary>
/// <returns>The reinterpreted vector.</returns>
[CLSCompliant(false)]
[Intrinsic]
- public static explicit operator Vector<UInt64>(Vector<T> value)
+ public static explicit operator Vector<ulong>(Vector<T> value)
{
- return new Vector<UInt64>(ref value.register);
+ return new Vector<ulong>(ref value.register);
}
/// <summary>
/// <param name="value">The source vector</param>
/// <returns>The reinterpreted vector.</returns>
[Intrinsic]
- public static explicit operator Vector<Int64>(Vector<T> value)
+ public static explicit operator Vector<long>(Vector<T> value)
{
- return new Vector<Int64>(ref value.register);
+ return new Vector<long>(ref value.register);
}
/// <summary>
/// <param name="value">The source vector</param>
/// <returns>The reinterpreted vector.</returns>
[Intrinsic]
- public static explicit operator Vector<Single>(Vector<T> value)
+ public static explicit operator Vector<float>(Vector<T> value)
{
- return new Vector<Single>(ref value.register);
+ return new Vector<float>(ref value.register);
}
/// <summary>
/// <param name="value">The source vector</param>
/// <returns>The reinterpreted vector.</returns>
[Intrinsic]
- public static explicit operator Vector<Double>(Vector<T> value)
+ public static explicit operator Vector<double>(Vector<T> value)
{
- return new Vector<Double>(ref value.register);
+ return new Vector<double>(ref value.register);
}
#endregion Conversions
{
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- Byte* dataPtr = stackalloc Byte[Count];
+ byte* dataPtr = stackalloc byte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
+ dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- SByte* dataPtr = stackalloc SByte[Count];
+ sbyte* dataPtr = stackalloc sbyte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
+ dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- UInt16* dataPtr = stackalloc UInt16[Count];
+ ushort* dataPtr = stackalloc ushort[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
+ dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16* dataPtr = stackalloc Int16[Count];
+ short* dataPtr = stackalloc short[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
+ dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32* dataPtr = stackalloc UInt32[Count];
+ uint* dataPtr = stackalloc uint[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
+ dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32* dataPtr = stackalloc Int32[Count];
+ int* dataPtr = stackalloc int[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
+ dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64* dataPtr = stackalloc UInt64[Count];
+ ulong* dataPtr = stackalloc ulong[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetUInt64WithAllBitsSet() : (UInt64)0;
+ dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetUInt64WithAllBitsSet() : (ulong)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64* dataPtr = stackalloc Int64[Count];
+ long* dataPtr = stackalloc long[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetInt64WithAllBitsSet() : (Int64)0;
+ dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetInt64WithAllBitsSet() : (long)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single* dataPtr = stackalloc Single[Count];
+ float* dataPtr = stackalloc float[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
+ dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double* dataPtr = stackalloc Double[Count];
+ double* dataPtr = stackalloc double[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetDoubleWithAllBitsSet() : (Double)0;
+ dataPtr[g] = ScalarEquals(left[g], right[g]) ? ConstantHelper.GetDoubleWithAllBitsSet() : (double)0;
}
return new Vector<T>(dataPtr);
}
else
{
Register register = new Register();
- if (typeof(T) == typeof(Byte))
- {
- register.byte_0 = left.register.byte_0 == right.register.byte_0 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_1 = left.register.byte_1 == right.register.byte_1 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_2 = left.register.byte_2 == right.register.byte_2 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_3 = left.register.byte_3 == right.register.byte_3 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_4 = left.register.byte_4 == right.register.byte_4 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_5 = left.register.byte_5 == right.register.byte_5 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_6 = left.register.byte_6 == right.register.byte_6 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_7 = left.register.byte_7 == right.register.byte_7 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_8 = left.register.byte_8 == right.register.byte_8 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_9 = left.register.byte_9 == right.register.byte_9 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_10 = left.register.byte_10 == right.register.byte_10 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_11 = left.register.byte_11 == right.register.byte_11 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_12 = left.register.byte_12 == right.register.byte_12 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_13 = left.register.byte_13 == right.register.byte_13 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_14 = left.register.byte_14 == right.register.byte_14 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_15 = left.register.byte_15 == right.register.byte_15 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
+ if (typeof(T) == typeof(byte))
+ {
+ register.byte_0 = left.register.byte_0 == right.register.byte_0 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_1 = left.register.byte_1 == right.register.byte_1 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_2 = left.register.byte_2 == right.register.byte_2 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_3 = left.register.byte_3 == right.register.byte_3 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_4 = left.register.byte_4 == right.register.byte_4 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_5 = left.register.byte_5 == right.register.byte_5 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_6 = left.register.byte_6 == right.register.byte_6 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_7 = left.register.byte_7 == right.register.byte_7 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_8 = left.register.byte_8 == right.register.byte_8 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_9 = left.register.byte_9 == right.register.byte_9 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_10 = left.register.byte_10 == right.register.byte_10 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_11 = left.register.byte_11 == right.register.byte_11 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_12 = left.register.byte_12 == right.register.byte_12 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_13 = left.register.byte_13 == right.register.byte_13 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_14 = left.register.byte_14 == right.register.byte_14 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_15 = left.register.byte_15 == right.register.byte_15 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(SByte))
- {
- register.sbyte_0 = left.register.sbyte_0 == right.register.sbyte_0 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_1 = left.register.sbyte_1 == right.register.sbyte_1 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_2 = left.register.sbyte_2 == right.register.sbyte_2 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_3 = left.register.sbyte_3 == right.register.sbyte_3 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_4 = left.register.sbyte_4 == right.register.sbyte_4 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_5 = left.register.sbyte_5 == right.register.sbyte_5 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_6 = left.register.sbyte_6 == right.register.sbyte_6 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_7 = left.register.sbyte_7 == right.register.sbyte_7 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_8 = left.register.sbyte_8 == right.register.sbyte_8 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_9 = left.register.sbyte_9 == right.register.sbyte_9 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_10 = left.register.sbyte_10 == right.register.sbyte_10 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_11 = left.register.sbyte_11 == right.register.sbyte_11 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_12 = left.register.sbyte_12 == right.register.sbyte_12 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_13 = left.register.sbyte_13 == right.register.sbyte_13 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_14 = left.register.sbyte_14 == right.register.sbyte_14 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_15 = left.register.sbyte_15 == right.register.sbyte_15 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
+ else if (typeof(T) == typeof(sbyte))
+ {
+ register.sbyte_0 = left.register.sbyte_0 == right.register.sbyte_0 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_1 = left.register.sbyte_1 == right.register.sbyte_1 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_2 = left.register.sbyte_2 == right.register.sbyte_2 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_3 = left.register.sbyte_3 == right.register.sbyte_3 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_4 = left.register.sbyte_4 == right.register.sbyte_4 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_5 = left.register.sbyte_5 == right.register.sbyte_5 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_6 = left.register.sbyte_6 == right.register.sbyte_6 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_7 = left.register.sbyte_7 == right.register.sbyte_7 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_8 = left.register.sbyte_8 == right.register.sbyte_8 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_9 = left.register.sbyte_9 == right.register.sbyte_9 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_10 = left.register.sbyte_10 == right.register.sbyte_10 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_11 = left.register.sbyte_11 == right.register.sbyte_11 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_12 = left.register.sbyte_12 == right.register.sbyte_12 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_13 = left.register.sbyte_13 == right.register.sbyte_13 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_14 = left.register.sbyte_14 == right.register.sbyte_14 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_15 = left.register.sbyte_15 == right.register.sbyte_15 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- register.uint16_0 = left.register.uint16_0 == right.register.uint16_0 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_1 = left.register.uint16_1 == right.register.uint16_1 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_2 = left.register.uint16_2 == right.register.uint16_2 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_3 = left.register.uint16_3 == right.register.uint16_3 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_4 = left.register.uint16_4 == right.register.uint16_4 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_5 = left.register.uint16_5 == right.register.uint16_5 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_6 = left.register.uint16_6 == right.register.uint16_6 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_7 = left.register.uint16_7 == right.register.uint16_7 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
+ register.uint16_0 = left.register.uint16_0 == right.register.uint16_0 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_1 = left.register.uint16_1 == right.register.uint16_1 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_2 = left.register.uint16_2 == right.register.uint16_2 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_3 = left.register.uint16_3 == right.register.uint16_3 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_4 = left.register.uint16_4 == right.register.uint16_4 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_5 = left.register.uint16_5 == right.register.uint16_5 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_6 = left.register.uint16_6 == right.register.uint16_6 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_7 = left.register.uint16_7 == right.register.uint16_7 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- register.int16_0 = left.register.int16_0 == right.register.int16_0 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_1 = left.register.int16_1 == right.register.int16_1 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_2 = left.register.int16_2 == right.register.int16_2 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_3 = left.register.int16_3 == right.register.int16_3 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_4 = left.register.int16_4 == right.register.int16_4 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_5 = left.register.int16_5 == right.register.int16_5 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_6 = left.register.int16_6 == right.register.int16_6 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_7 = left.register.int16_7 == right.register.int16_7 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
+ register.int16_0 = left.register.int16_0 == right.register.int16_0 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_1 = left.register.int16_1 == right.register.int16_1 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_2 = left.register.int16_2 == right.register.int16_2 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_3 = left.register.int16_3 == right.register.int16_3 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_4 = left.register.int16_4 == right.register.int16_4 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_5 = left.register.int16_5 == right.register.int16_5 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_6 = left.register.int16_6 == right.register.int16_6 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_7 = left.register.int16_7 == right.register.int16_7 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- register.uint32_0 = left.register.uint32_0 == right.register.uint32_0 ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
- register.uint32_1 = left.register.uint32_1 == right.register.uint32_1 ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
- register.uint32_2 = left.register.uint32_2 == right.register.uint32_2 ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
- register.uint32_3 = left.register.uint32_3 == right.register.uint32_3 ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
+ register.uint32_0 = left.register.uint32_0 == right.register.uint32_0 ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
+ register.uint32_1 = left.register.uint32_1 == right.register.uint32_1 ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
+ register.uint32_2 = left.register.uint32_2 == right.register.uint32_2 ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
+ register.uint32_3 = left.register.uint32_3 == right.register.uint32_3 ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- register.int32_0 = left.register.int32_0 == right.register.int32_0 ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
- register.int32_1 = left.register.int32_1 == right.register.int32_1 ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
- register.int32_2 = left.register.int32_2 == right.register.int32_2 ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
- register.int32_3 = left.register.int32_3 == right.register.int32_3 ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
+ register.int32_0 = left.register.int32_0 == right.register.int32_0 ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
+ register.int32_1 = left.register.int32_1 == right.register.int32_1 ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
+ register.int32_2 = left.register.int32_2 == right.register.int32_2 ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
+ register.int32_3 = left.register.int32_3 == right.register.int32_3 ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- register.uint64_0 = left.register.uint64_0 == right.register.uint64_0 ? ConstantHelper.GetUInt64WithAllBitsSet() : (UInt64)0;
- register.uint64_1 = left.register.uint64_1 == right.register.uint64_1 ? ConstantHelper.GetUInt64WithAllBitsSet() : (UInt64)0;
+ register.uint64_0 = left.register.uint64_0 == right.register.uint64_0 ? ConstantHelper.GetUInt64WithAllBitsSet() : (ulong)0;
+ register.uint64_1 = left.register.uint64_1 == right.register.uint64_1 ? ConstantHelper.GetUInt64WithAllBitsSet() : (ulong)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- register.int64_0 = left.register.int64_0 == right.register.int64_0 ? ConstantHelper.GetInt64WithAllBitsSet() : (Int64)0;
- register.int64_1 = left.register.int64_1 == right.register.int64_1 ? ConstantHelper.GetInt64WithAllBitsSet() : (Int64)0;
+ register.int64_0 = left.register.int64_0 == right.register.int64_0 ? ConstantHelper.GetInt64WithAllBitsSet() : (long)0;
+ register.int64_1 = left.register.int64_1 == right.register.int64_1 ? ConstantHelper.GetInt64WithAllBitsSet() : (long)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- register.single_0 = left.register.single_0 == right.register.single_0 ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
- register.single_1 = left.register.single_1 == right.register.single_1 ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
- register.single_2 = left.register.single_2 == right.register.single_2 ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
- register.single_3 = left.register.single_3 == right.register.single_3 ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
+ register.single_0 = left.register.single_0 == right.register.single_0 ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
+ register.single_1 = left.register.single_1 == right.register.single_1 ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
+ register.single_2 = left.register.single_2 == right.register.single_2 ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
+ register.single_3 = left.register.single_3 == right.register.single_3 ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- register.double_0 = left.register.double_0 == right.register.double_0 ? ConstantHelper.GetDoubleWithAllBitsSet() : (Double)0;
- register.double_1 = left.register.double_1 == right.register.double_1 ? ConstantHelper.GetDoubleWithAllBitsSet() : (Double)0;
+ register.double_0 = left.register.double_0 == right.register.double_0 ? ConstantHelper.GetDoubleWithAllBitsSet() : (double)0;
+ register.double_1 = left.register.double_1 == right.register.double_1 ? ConstantHelper.GetDoubleWithAllBitsSet() : (double)0;
return new Vector<T>(ref register);
}
else
{
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- Byte* dataPtr = stackalloc Byte[Count];
+ byte* dataPtr = stackalloc byte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- SByte* dataPtr = stackalloc SByte[Count];
+ sbyte* dataPtr = stackalloc sbyte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- UInt16* dataPtr = stackalloc UInt16[Count];
+ ushort* dataPtr = stackalloc ushort[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16* dataPtr = stackalloc Int16[Count];
+ short* dataPtr = stackalloc short[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32* dataPtr = stackalloc UInt32[Count];
+ uint* dataPtr = stackalloc uint[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32* dataPtr = stackalloc Int32[Count];
+ int* dataPtr = stackalloc int[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64* dataPtr = stackalloc UInt64[Count];
+ ulong* dataPtr = stackalloc ulong[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetUInt64WithAllBitsSet() : (UInt64)0;
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetUInt64WithAllBitsSet() : (ulong)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64* dataPtr = stackalloc Int64[Count];
+ long* dataPtr = stackalloc long[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetInt64WithAllBitsSet() : (Int64)0;
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetInt64WithAllBitsSet() : (long)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single* dataPtr = stackalloc Single[Count];
+ float* dataPtr = stackalloc float[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double* dataPtr = stackalloc Double[Count];
+ double* dataPtr = stackalloc double[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetDoubleWithAllBitsSet() : (Double)0;
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? ConstantHelper.GetDoubleWithAllBitsSet() : (double)0;
}
return new Vector<T>(dataPtr);
}
else
{
Register register = new Register();
- if (typeof(T) == typeof(Byte))
- {
- register.byte_0 = left.register.byte_0 < right.register.byte_0 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_1 = left.register.byte_1 < right.register.byte_1 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_2 = left.register.byte_2 < right.register.byte_2 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_3 = left.register.byte_3 < right.register.byte_3 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_4 = left.register.byte_4 < right.register.byte_4 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_5 = left.register.byte_5 < right.register.byte_5 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_6 = left.register.byte_6 < right.register.byte_6 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_7 = left.register.byte_7 < right.register.byte_7 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_8 = left.register.byte_8 < right.register.byte_8 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_9 = left.register.byte_9 < right.register.byte_9 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_10 = left.register.byte_10 < right.register.byte_10 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_11 = left.register.byte_11 < right.register.byte_11 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_12 = left.register.byte_12 < right.register.byte_12 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_13 = left.register.byte_13 < right.register.byte_13 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_14 = left.register.byte_14 < right.register.byte_14 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_15 = left.register.byte_15 < right.register.byte_15 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
+ if (typeof(T) == typeof(byte))
+ {
+ register.byte_0 = left.register.byte_0 < right.register.byte_0 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_1 = left.register.byte_1 < right.register.byte_1 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_2 = left.register.byte_2 < right.register.byte_2 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_3 = left.register.byte_3 < right.register.byte_3 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_4 = left.register.byte_4 < right.register.byte_4 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_5 = left.register.byte_5 < right.register.byte_5 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_6 = left.register.byte_6 < right.register.byte_6 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_7 = left.register.byte_7 < right.register.byte_7 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_8 = left.register.byte_8 < right.register.byte_8 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_9 = left.register.byte_9 < right.register.byte_9 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_10 = left.register.byte_10 < right.register.byte_10 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_11 = left.register.byte_11 < right.register.byte_11 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_12 = left.register.byte_12 < right.register.byte_12 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_13 = left.register.byte_13 < right.register.byte_13 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_14 = left.register.byte_14 < right.register.byte_14 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_15 = left.register.byte_15 < right.register.byte_15 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(SByte))
- {
- register.sbyte_0 = left.register.sbyte_0 < right.register.sbyte_0 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_1 = left.register.sbyte_1 < right.register.sbyte_1 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_2 = left.register.sbyte_2 < right.register.sbyte_2 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_3 = left.register.sbyte_3 < right.register.sbyte_3 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_4 = left.register.sbyte_4 < right.register.sbyte_4 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_5 = left.register.sbyte_5 < right.register.sbyte_5 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_6 = left.register.sbyte_6 < right.register.sbyte_6 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_7 = left.register.sbyte_7 < right.register.sbyte_7 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_8 = left.register.sbyte_8 < right.register.sbyte_8 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_9 = left.register.sbyte_9 < right.register.sbyte_9 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_10 = left.register.sbyte_10 < right.register.sbyte_10 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_11 = left.register.sbyte_11 < right.register.sbyte_11 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_12 = left.register.sbyte_12 < right.register.sbyte_12 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_13 = left.register.sbyte_13 < right.register.sbyte_13 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_14 = left.register.sbyte_14 < right.register.sbyte_14 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_15 = left.register.sbyte_15 < right.register.sbyte_15 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
+ else if (typeof(T) == typeof(sbyte))
+ {
+ register.sbyte_0 = left.register.sbyte_0 < right.register.sbyte_0 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_1 = left.register.sbyte_1 < right.register.sbyte_1 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_2 = left.register.sbyte_2 < right.register.sbyte_2 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_3 = left.register.sbyte_3 < right.register.sbyte_3 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_4 = left.register.sbyte_4 < right.register.sbyte_4 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_5 = left.register.sbyte_5 < right.register.sbyte_5 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_6 = left.register.sbyte_6 < right.register.sbyte_6 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_7 = left.register.sbyte_7 < right.register.sbyte_7 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_8 = left.register.sbyte_8 < right.register.sbyte_8 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_9 = left.register.sbyte_9 < right.register.sbyte_9 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_10 = left.register.sbyte_10 < right.register.sbyte_10 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_11 = left.register.sbyte_11 < right.register.sbyte_11 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_12 = left.register.sbyte_12 < right.register.sbyte_12 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_13 = left.register.sbyte_13 < right.register.sbyte_13 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_14 = left.register.sbyte_14 < right.register.sbyte_14 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_15 = left.register.sbyte_15 < right.register.sbyte_15 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- register.uint16_0 = left.register.uint16_0 < right.register.uint16_0 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_1 = left.register.uint16_1 < right.register.uint16_1 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_2 = left.register.uint16_2 < right.register.uint16_2 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_3 = left.register.uint16_3 < right.register.uint16_3 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_4 = left.register.uint16_4 < right.register.uint16_4 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_5 = left.register.uint16_5 < right.register.uint16_5 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_6 = left.register.uint16_6 < right.register.uint16_6 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_7 = left.register.uint16_7 < right.register.uint16_7 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
+ register.uint16_0 = left.register.uint16_0 < right.register.uint16_0 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_1 = left.register.uint16_1 < right.register.uint16_1 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_2 = left.register.uint16_2 < right.register.uint16_2 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_3 = left.register.uint16_3 < right.register.uint16_3 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_4 = left.register.uint16_4 < right.register.uint16_4 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_5 = left.register.uint16_5 < right.register.uint16_5 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_6 = left.register.uint16_6 < right.register.uint16_6 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_7 = left.register.uint16_7 < right.register.uint16_7 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- register.int16_0 = left.register.int16_0 < right.register.int16_0 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_1 = left.register.int16_1 < right.register.int16_1 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_2 = left.register.int16_2 < right.register.int16_2 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_3 = left.register.int16_3 < right.register.int16_3 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_4 = left.register.int16_4 < right.register.int16_4 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_5 = left.register.int16_5 < right.register.int16_5 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_6 = left.register.int16_6 < right.register.int16_6 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_7 = left.register.int16_7 < right.register.int16_7 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
+ register.int16_0 = left.register.int16_0 < right.register.int16_0 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_1 = left.register.int16_1 < right.register.int16_1 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_2 = left.register.int16_2 < right.register.int16_2 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_3 = left.register.int16_3 < right.register.int16_3 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_4 = left.register.int16_4 < right.register.int16_4 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_5 = left.register.int16_5 < right.register.int16_5 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_6 = left.register.int16_6 < right.register.int16_6 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_7 = left.register.int16_7 < right.register.int16_7 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- register.uint32_0 = left.register.uint32_0 < right.register.uint32_0 ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
- register.uint32_1 = left.register.uint32_1 < right.register.uint32_1 ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
- register.uint32_2 = left.register.uint32_2 < right.register.uint32_2 ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
- register.uint32_3 = left.register.uint32_3 < right.register.uint32_3 ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
+ register.uint32_0 = left.register.uint32_0 < right.register.uint32_0 ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
+ register.uint32_1 = left.register.uint32_1 < right.register.uint32_1 ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
+ register.uint32_2 = left.register.uint32_2 < right.register.uint32_2 ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
+ register.uint32_3 = left.register.uint32_3 < right.register.uint32_3 ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- register.int32_0 = left.register.int32_0 < right.register.int32_0 ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
- register.int32_1 = left.register.int32_1 < right.register.int32_1 ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
- register.int32_2 = left.register.int32_2 < right.register.int32_2 ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
- register.int32_3 = left.register.int32_3 < right.register.int32_3 ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
+ register.int32_0 = left.register.int32_0 < right.register.int32_0 ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
+ register.int32_1 = left.register.int32_1 < right.register.int32_1 ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
+ register.int32_2 = left.register.int32_2 < right.register.int32_2 ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
+ register.int32_3 = left.register.int32_3 < right.register.int32_3 ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- register.uint64_0 = left.register.uint64_0 < right.register.uint64_0 ? ConstantHelper.GetUInt64WithAllBitsSet() : (UInt64)0;
- register.uint64_1 = left.register.uint64_1 < right.register.uint64_1 ? ConstantHelper.GetUInt64WithAllBitsSet() : (UInt64)0;
+ register.uint64_0 = left.register.uint64_0 < right.register.uint64_0 ? ConstantHelper.GetUInt64WithAllBitsSet() : (ulong)0;
+ register.uint64_1 = left.register.uint64_1 < right.register.uint64_1 ? ConstantHelper.GetUInt64WithAllBitsSet() : (ulong)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- register.int64_0 = left.register.int64_0 < right.register.int64_0 ? ConstantHelper.GetInt64WithAllBitsSet() : (Int64)0;
- register.int64_1 = left.register.int64_1 < right.register.int64_1 ? ConstantHelper.GetInt64WithAllBitsSet() : (Int64)0;
+ register.int64_0 = left.register.int64_0 < right.register.int64_0 ? ConstantHelper.GetInt64WithAllBitsSet() : (long)0;
+ register.int64_1 = left.register.int64_1 < right.register.int64_1 ? ConstantHelper.GetInt64WithAllBitsSet() : (long)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- register.single_0 = left.register.single_0 < right.register.single_0 ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
- register.single_1 = left.register.single_1 < right.register.single_1 ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
- register.single_2 = left.register.single_2 < right.register.single_2 ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
- register.single_3 = left.register.single_3 < right.register.single_3 ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
+ register.single_0 = left.register.single_0 < right.register.single_0 ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
+ register.single_1 = left.register.single_1 < right.register.single_1 ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
+ register.single_2 = left.register.single_2 < right.register.single_2 ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
+ register.single_3 = left.register.single_3 < right.register.single_3 ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- register.double_0 = left.register.double_0 < right.register.double_0 ? ConstantHelper.GetDoubleWithAllBitsSet() : (Double)0;
- register.double_1 = left.register.double_1 < right.register.double_1 ? ConstantHelper.GetDoubleWithAllBitsSet() : (Double)0;
+ register.double_0 = left.register.double_0 < right.register.double_0 ? ConstantHelper.GetDoubleWithAllBitsSet() : (double)0;
+ register.double_1 = left.register.double_1 < right.register.double_1 ? ConstantHelper.GetDoubleWithAllBitsSet() : (double)0;
return new Vector<T>(ref register);
}
else
{
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- Byte* dataPtr = stackalloc Byte[Count];
+ byte* dataPtr = stackalloc byte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- SByte* dataPtr = stackalloc SByte[Count];
+ sbyte* dataPtr = stackalloc sbyte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- UInt16* dataPtr = stackalloc UInt16[Count];
+ ushort* dataPtr = stackalloc ushort[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16* dataPtr = stackalloc Int16[Count];
+ short* dataPtr = stackalloc short[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32* dataPtr = stackalloc UInt32[Count];
+ uint* dataPtr = stackalloc uint[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32* dataPtr = stackalloc Int32[Count];
+ int* dataPtr = stackalloc int[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64* dataPtr = stackalloc UInt64[Count];
+ ulong* dataPtr = stackalloc ulong[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetUInt64WithAllBitsSet() : (UInt64)0;
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetUInt64WithAllBitsSet() : (ulong)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64* dataPtr = stackalloc Int64[Count];
+ long* dataPtr = stackalloc long[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetInt64WithAllBitsSet() : (Int64)0;
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetInt64WithAllBitsSet() : (long)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single* dataPtr = stackalloc Single[Count];
+ float* dataPtr = stackalloc float[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double* dataPtr = stackalloc Double[Count];
+ double* dataPtr = stackalloc double[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetDoubleWithAllBitsSet() : (Double)0;
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? ConstantHelper.GetDoubleWithAllBitsSet() : (double)0;
}
return new Vector<T>(dataPtr);
}
else
{
Register register = new Register();
- if (typeof(T) == typeof(Byte))
- {
- register.byte_0 = left.register.byte_0 > right.register.byte_0 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_1 = left.register.byte_1 > right.register.byte_1 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_2 = left.register.byte_2 > right.register.byte_2 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_3 = left.register.byte_3 > right.register.byte_3 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_4 = left.register.byte_4 > right.register.byte_4 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_5 = left.register.byte_5 > right.register.byte_5 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_6 = left.register.byte_6 > right.register.byte_6 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_7 = left.register.byte_7 > right.register.byte_7 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_8 = left.register.byte_8 > right.register.byte_8 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_9 = left.register.byte_9 > right.register.byte_9 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_10 = left.register.byte_10 > right.register.byte_10 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_11 = left.register.byte_11 > right.register.byte_11 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_12 = left.register.byte_12 > right.register.byte_12 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_13 = left.register.byte_13 > right.register.byte_13 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_14 = left.register.byte_14 > right.register.byte_14 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
- register.byte_15 = left.register.byte_15 > right.register.byte_15 ? ConstantHelper.GetByteWithAllBitsSet() : (Byte)0;
+ if (typeof(T) == typeof(byte))
+ {
+ register.byte_0 = left.register.byte_0 > right.register.byte_0 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_1 = left.register.byte_1 > right.register.byte_1 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_2 = left.register.byte_2 > right.register.byte_2 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_3 = left.register.byte_3 > right.register.byte_3 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_4 = left.register.byte_4 > right.register.byte_4 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_5 = left.register.byte_5 > right.register.byte_5 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_6 = left.register.byte_6 > right.register.byte_6 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_7 = left.register.byte_7 > right.register.byte_7 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_8 = left.register.byte_8 > right.register.byte_8 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_9 = left.register.byte_9 > right.register.byte_9 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_10 = left.register.byte_10 > right.register.byte_10 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_11 = left.register.byte_11 > right.register.byte_11 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_12 = left.register.byte_12 > right.register.byte_12 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_13 = left.register.byte_13 > right.register.byte_13 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_14 = left.register.byte_14 > right.register.byte_14 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
+ register.byte_15 = left.register.byte_15 > right.register.byte_15 ? ConstantHelper.GetByteWithAllBitsSet() : (byte)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(SByte))
- {
- register.sbyte_0 = left.register.sbyte_0 > right.register.sbyte_0 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_1 = left.register.sbyte_1 > right.register.sbyte_1 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_2 = left.register.sbyte_2 > right.register.sbyte_2 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_3 = left.register.sbyte_3 > right.register.sbyte_3 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_4 = left.register.sbyte_4 > right.register.sbyte_4 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_5 = left.register.sbyte_5 > right.register.sbyte_5 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_6 = left.register.sbyte_6 > right.register.sbyte_6 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_7 = left.register.sbyte_7 > right.register.sbyte_7 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_8 = left.register.sbyte_8 > right.register.sbyte_8 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_9 = left.register.sbyte_9 > right.register.sbyte_9 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_10 = left.register.sbyte_10 > right.register.sbyte_10 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_11 = left.register.sbyte_11 > right.register.sbyte_11 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_12 = left.register.sbyte_12 > right.register.sbyte_12 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_13 = left.register.sbyte_13 > right.register.sbyte_13 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_14 = left.register.sbyte_14 > right.register.sbyte_14 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
- register.sbyte_15 = left.register.sbyte_15 > right.register.sbyte_15 ? ConstantHelper.GetSByteWithAllBitsSet() : (SByte)0;
+ else if (typeof(T) == typeof(sbyte))
+ {
+ register.sbyte_0 = left.register.sbyte_0 > right.register.sbyte_0 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_1 = left.register.sbyte_1 > right.register.sbyte_1 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_2 = left.register.sbyte_2 > right.register.sbyte_2 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_3 = left.register.sbyte_3 > right.register.sbyte_3 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_4 = left.register.sbyte_4 > right.register.sbyte_4 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_5 = left.register.sbyte_5 > right.register.sbyte_5 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_6 = left.register.sbyte_6 > right.register.sbyte_6 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_7 = left.register.sbyte_7 > right.register.sbyte_7 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_8 = left.register.sbyte_8 > right.register.sbyte_8 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_9 = left.register.sbyte_9 > right.register.sbyte_9 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_10 = left.register.sbyte_10 > right.register.sbyte_10 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_11 = left.register.sbyte_11 > right.register.sbyte_11 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_12 = left.register.sbyte_12 > right.register.sbyte_12 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_13 = left.register.sbyte_13 > right.register.sbyte_13 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_14 = left.register.sbyte_14 > right.register.sbyte_14 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
+ register.sbyte_15 = left.register.sbyte_15 > right.register.sbyte_15 ? ConstantHelper.GetSByteWithAllBitsSet() : (sbyte)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- register.uint16_0 = left.register.uint16_0 > right.register.uint16_0 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_1 = left.register.uint16_1 > right.register.uint16_1 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_2 = left.register.uint16_2 > right.register.uint16_2 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_3 = left.register.uint16_3 > right.register.uint16_3 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_4 = left.register.uint16_4 > right.register.uint16_4 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_5 = left.register.uint16_5 > right.register.uint16_5 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_6 = left.register.uint16_6 > right.register.uint16_6 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
- register.uint16_7 = left.register.uint16_7 > right.register.uint16_7 ? ConstantHelper.GetUInt16WithAllBitsSet() : (UInt16)0;
+ register.uint16_0 = left.register.uint16_0 > right.register.uint16_0 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_1 = left.register.uint16_1 > right.register.uint16_1 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_2 = left.register.uint16_2 > right.register.uint16_2 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_3 = left.register.uint16_3 > right.register.uint16_3 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_4 = left.register.uint16_4 > right.register.uint16_4 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_5 = left.register.uint16_5 > right.register.uint16_5 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_6 = left.register.uint16_6 > right.register.uint16_6 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
+ register.uint16_7 = left.register.uint16_7 > right.register.uint16_7 ? ConstantHelper.GetUInt16WithAllBitsSet() : (ushort)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- register.int16_0 = left.register.int16_0 > right.register.int16_0 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_1 = left.register.int16_1 > right.register.int16_1 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_2 = left.register.int16_2 > right.register.int16_2 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_3 = left.register.int16_3 > right.register.int16_3 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_4 = left.register.int16_4 > right.register.int16_4 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_5 = left.register.int16_5 > right.register.int16_5 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_6 = left.register.int16_6 > right.register.int16_6 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
- register.int16_7 = left.register.int16_7 > right.register.int16_7 ? ConstantHelper.GetInt16WithAllBitsSet() : (Int16)0;
+ register.int16_0 = left.register.int16_0 > right.register.int16_0 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_1 = left.register.int16_1 > right.register.int16_1 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_2 = left.register.int16_2 > right.register.int16_2 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_3 = left.register.int16_3 > right.register.int16_3 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_4 = left.register.int16_4 > right.register.int16_4 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_5 = left.register.int16_5 > right.register.int16_5 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_6 = left.register.int16_6 > right.register.int16_6 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
+ register.int16_7 = left.register.int16_7 > right.register.int16_7 ? ConstantHelper.GetInt16WithAllBitsSet() : (short)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- register.uint32_0 = left.register.uint32_0 > right.register.uint32_0 ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
- register.uint32_1 = left.register.uint32_1 > right.register.uint32_1 ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
- register.uint32_2 = left.register.uint32_2 > right.register.uint32_2 ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
- register.uint32_3 = left.register.uint32_3 > right.register.uint32_3 ? ConstantHelper.GetUInt32WithAllBitsSet() : (UInt32)0;
+ register.uint32_0 = left.register.uint32_0 > right.register.uint32_0 ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
+ register.uint32_1 = left.register.uint32_1 > right.register.uint32_1 ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
+ register.uint32_2 = left.register.uint32_2 > right.register.uint32_2 ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
+ register.uint32_3 = left.register.uint32_3 > right.register.uint32_3 ? ConstantHelper.GetUInt32WithAllBitsSet() : (uint)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- register.int32_0 = left.register.int32_0 > right.register.int32_0 ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
- register.int32_1 = left.register.int32_1 > right.register.int32_1 ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
- register.int32_2 = left.register.int32_2 > right.register.int32_2 ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
- register.int32_3 = left.register.int32_3 > right.register.int32_3 ? ConstantHelper.GetInt32WithAllBitsSet() : (Int32)0;
+ register.int32_0 = left.register.int32_0 > right.register.int32_0 ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
+ register.int32_1 = left.register.int32_1 > right.register.int32_1 ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
+ register.int32_2 = left.register.int32_2 > right.register.int32_2 ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
+ register.int32_3 = left.register.int32_3 > right.register.int32_3 ? ConstantHelper.GetInt32WithAllBitsSet() : (int)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- register.uint64_0 = left.register.uint64_0 > right.register.uint64_0 ? ConstantHelper.GetUInt64WithAllBitsSet() : (UInt64)0;
- register.uint64_1 = left.register.uint64_1 > right.register.uint64_1 ? ConstantHelper.GetUInt64WithAllBitsSet() : (UInt64)0;
+ register.uint64_0 = left.register.uint64_0 > right.register.uint64_0 ? ConstantHelper.GetUInt64WithAllBitsSet() : (ulong)0;
+ register.uint64_1 = left.register.uint64_1 > right.register.uint64_1 ? ConstantHelper.GetUInt64WithAllBitsSet() : (ulong)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- register.int64_0 = left.register.int64_0 > right.register.int64_0 ? ConstantHelper.GetInt64WithAllBitsSet() : (Int64)0;
- register.int64_1 = left.register.int64_1 > right.register.int64_1 ? ConstantHelper.GetInt64WithAllBitsSet() : (Int64)0;
+ register.int64_0 = left.register.int64_0 > right.register.int64_0 ? ConstantHelper.GetInt64WithAllBitsSet() : (long)0;
+ register.int64_1 = left.register.int64_1 > right.register.int64_1 ? ConstantHelper.GetInt64WithAllBitsSet() : (long)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- register.single_0 = left.register.single_0 > right.register.single_0 ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
- register.single_1 = left.register.single_1 > right.register.single_1 ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
- register.single_2 = left.register.single_2 > right.register.single_2 ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
- register.single_3 = left.register.single_3 > right.register.single_3 ? ConstantHelper.GetSingleWithAllBitsSet() : (Single)0;
+ register.single_0 = left.register.single_0 > right.register.single_0 ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
+ register.single_1 = left.register.single_1 > right.register.single_1 ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
+ register.single_2 = left.register.single_2 > right.register.single_2 ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
+ register.single_3 = left.register.single_3 > right.register.single_3 ? ConstantHelper.GetSingleWithAllBitsSet() : (float)0;
return new Vector<T>(ref register);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- register.double_0 = left.register.double_0 > right.register.double_0 ? ConstantHelper.GetDoubleWithAllBitsSet() : (Double)0;
- register.double_1 = left.register.double_1 > right.register.double_1 ? ConstantHelper.GetDoubleWithAllBitsSet() : (Double)0;
+ register.double_0 = left.register.double_0 > right.register.double_0 ? ConstantHelper.GetDoubleWithAllBitsSet() : (double)0;
+ register.double_1 = left.register.double_1 > right.register.double_1 ? ConstantHelper.GetDoubleWithAllBitsSet() : (double)0;
return new Vector<T>(ref register);
}
else
[Intrinsic]
internal static unsafe Vector<T> Abs(Vector<T> value)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
return value;
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
return value;
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
return value;
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
return value;
}
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(SByte))
+ if (typeof(T) == typeof(sbyte))
{
- SByte* dataPtr = stackalloc SByte[Count];
+ sbyte* dataPtr = stackalloc sbyte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (SByte)(object)(Math.Abs((SByte)(object)value[g]));
+ dataPtr[g] = (sbyte)(object)(Math.Abs((sbyte)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16* dataPtr = stackalloc Int16[Count];
+ short* dataPtr = stackalloc short[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int16)(object)(Math.Abs((Int16)(object)value[g]));
+ dataPtr[g] = (short)(object)(Math.Abs((short)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32* dataPtr = stackalloc Int32[Count];
+ int* dataPtr = stackalloc int[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int32)(object)(Math.Abs((Int32)(object)value[g]));
+ dataPtr[g] = (int)(object)(Math.Abs((int)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64* dataPtr = stackalloc Int64[Count];
+ long* dataPtr = stackalloc long[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Int64)(object)(Math.Abs((Int64)(object)value[g]));
+ dataPtr[g] = (long)(object)(Math.Abs((long)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single* dataPtr = stackalloc Single[Count];
+ float* dataPtr = stackalloc float[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Single)(object)(Math.Abs((Single)(object)value[g]));
+ dataPtr[g] = (float)(object)(Math.Abs((float)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double* dataPtr = stackalloc Double[Count];
+ double* dataPtr = stackalloc double[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = (Double)(object)(Math.Abs((Double)(object)value[g]));
+ dataPtr[g] = (double)(object)(Math.Abs((double)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
}
else
{
- if (typeof(T) == typeof(SByte))
- {
- value.register.sbyte_0 = (SByte)(Math.Abs(value.register.sbyte_0));
- value.register.sbyte_1 = (SByte)(Math.Abs(value.register.sbyte_1));
- value.register.sbyte_2 = (SByte)(Math.Abs(value.register.sbyte_2));
- value.register.sbyte_3 = (SByte)(Math.Abs(value.register.sbyte_3));
- value.register.sbyte_4 = (SByte)(Math.Abs(value.register.sbyte_4));
- value.register.sbyte_5 = (SByte)(Math.Abs(value.register.sbyte_5));
- value.register.sbyte_6 = (SByte)(Math.Abs(value.register.sbyte_6));
- value.register.sbyte_7 = (SByte)(Math.Abs(value.register.sbyte_7));
- value.register.sbyte_8 = (SByte)(Math.Abs(value.register.sbyte_8));
- value.register.sbyte_9 = (SByte)(Math.Abs(value.register.sbyte_9));
- value.register.sbyte_10 = (SByte)(Math.Abs(value.register.sbyte_10));
- value.register.sbyte_11 = (SByte)(Math.Abs(value.register.sbyte_11));
- value.register.sbyte_12 = (SByte)(Math.Abs(value.register.sbyte_12));
- value.register.sbyte_13 = (SByte)(Math.Abs(value.register.sbyte_13));
- value.register.sbyte_14 = (SByte)(Math.Abs(value.register.sbyte_14));
- value.register.sbyte_15 = (SByte)(Math.Abs(value.register.sbyte_15));
+ if (typeof(T) == typeof(sbyte))
+ {
+ value.register.sbyte_0 = (sbyte)(Math.Abs(value.register.sbyte_0));
+ value.register.sbyte_1 = (sbyte)(Math.Abs(value.register.sbyte_1));
+ value.register.sbyte_2 = (sbyte)(Math.Abs(value.register.sbyte_2));
+ value.register.sbyte_3 = (sbyte)(Math.Abs(value.register.sbyte_3));
+ value.register.sbyte_4 = (sbyte)(Math.Abs(value.register.sbyte_4));
+ value.register.sbyte_5 = (sbyte)(Math.Abs(value.register.sbyte_5));
+ value.register.sbyte_6 = (sbyte)(Math.Abs(value.register.sbyte_6));
+ value.register.sbyte_7 = (sbyte)(Math.Abs(value.register.sbyte_7));
+ value.register.sbyte_8 = (sbyte)(Math.Abs(value.register.sbyte_8));
+ value.register.sbyte_9 = (sbyte)(Math.Abs(value.register.sbyte_9));
+ value.register.sbyte_10 = (sbyte)(Math.Abs(value.register.sbyte_10));
+ value.register.sbyte_11 = (sbyte)(Math.Abs(value.register.sbyte_11));
+ value.register.sbyte_12 = (sbyte)(Math.Abs(value.register.sbyte_12));
+ value.register.sbyte_13 = (sbyte)(Math.Abs(value.register.sbyte_13));
+ value.register.sbyte_14 = (sbyte)(Math.Abs(value.register.sbyte_14));
+ value.register.sbyte_15 = (sbyte)(Math.Abs(value.register.sbyte_15));
return value;
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- value.register.int16_0 = (Int16)(Math.Abs(value.register.int16_0));
- value.register.int16_1 = (Int16)(Math.Abs(value.register.int16_1));
- value.register.int16_2 = (Int16)(Math.Abs(value.register.int16_2));
- value.register.int16_3 = (Int16)(Math.Abs(value.register.int16_3));
- value.register.int16_4 = (Int16)(Math.Abs(value.register.int16_4));
- value.register.int16_5 = (Int16)(Math.Abs(value.register.int16_5));
- value.register.int16_6 = (Int16)(Math.Abs(value.register.int16_6));
- value.register.int16_7 = (Int16)(Math.Abs(value.register.int16_7));
+ value.register.int16_0 = (short)(Math.Abs(value.register.int16_0));
+ value.register.int16_1 = (short)(Math.Abs(value.register.int16_1));
+ value.register.int16_2 = (short)(Math.Abs(value.register.int16_2));
+ value.register.int16_3 = (short)(Math.Abs(value.register.int16_3));
+ value.register.int16_4 = (short)(Math.Abs(value.register.int16_4));
+ value.register.int16_5 = (short)(Math.Abs(value.register.int16_5));
+ value.register.int16_6 = (short)(Math.Abs(value.register.int16_6));
+ value.register.int16_7 = (short)(Math.Abs(value.register.int16_7));
return value;
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- value.register.int32_0 = (Int32)(Math.Abs(value.register.int32_0));
- value.register.int32_1 = (Int32)(Math.Abs(value.register.int32_1));
- value.register.int32_2 = (Int32)(Math.Abs(value.register.int32_2));
- value.register.int32_3 = (Int32)(Math.Abs(value.register.int32_3));
+ value.register.int32_0 = (int)(Math.Abs(value.register.int32_0));
+ value.register.int32_1 = (int)(Math.Abs(value.register.int32_1));
+ value.register.int32_2 = (int)(Math.Abs(value.register.int32_2));
+ value.register.int32_3 = (int)(Math.Abs(value.register.int32_3));
return value;
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- value.register.int64_0 = (Int64)(Math.Abs(value.register.int64_0));
- value.register.int64_1 = (Int64)(Math.Abs(value.register.int64_1));
+ value.register.int64_0 = (long)(Math.Abs(value.register.int64_0));
+ value.register.int64_1 = (long)(Math.Abs(value.register.int64_1));
return value;
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- value.register.single_0 = (Single)(Math.Abs(value.register.single_0));
- value.register.single_1 = (Single)(Math.Abs(value.register.single_1));
- value.register.single_2 = (Single)(Math.Abs(value.register.single_2));
- value.register.single_3 = (Single)(Math.Abs(value.register.single_3));
+ value.register.single_0 = (float)(Math.Abs(value.register.single_0));
+ value.register.single_1 = (float)(Math.Abs(value.register.single_1));
+ value.register.single_2 = (float)(Math.Abs(value.register.single_2));
+ value.register.single_3 = (float)(Math.Abs(value.register.single_3));
return value;
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- value.register.double_0 = (Double)(Math.Abs(value.register.double_0));
- value.register.double_1 = (Double)(Math.Abs(value.register.double_1));
+ value.register.double_0 = (double)(Math.Abs(value.register.double_0));
+ value.register.double_1 = (double)(Math.Abs(value.register.double_1));
return value;
}
else
{
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- Byte* dataPtr = stackalloc Byte[Count];
+ byte* dataPtr = stackalloc byte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (Byte)(object)left[g] : (Byte)(object)right[g];
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (byte)(object)left[g] : (byte)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- SByte* dataPtr = stackalloc SByte[Count];
+ sbyte* dataPtr = stackalloc sbyte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (SByte)(object)left[g] : (SByte)(object)right[g];
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (sbyte)(object)left[g] : (sbyte)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- UInt16* dataPtr = stackalloc UInt16[Count];
+ ushort* dataPtr = stackalloc ushort[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (UInt16)(object)left[g] : (UInt16)(object)right[g];
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (ushort)(object)left[g] : (ushort)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16* dataPtr = stackalloc Int16[Count];
+ short* dataPtr = stackalloc short[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (Int16)(object)left[g] : (Int16)(object)right[g];
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (short)(object)left[g] : (short)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32* dataPtr = stackalloc UInt32[Count];
+ uint* dataPtr = stackalloc uint[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (UInt32)(object)left[g] : (UInt32)(object)right[g];
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (uint)(object)left[g] : (uint)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32* dataPtr = stackalloc Int32[Count];
+ int* dataPtr = stackalloc int[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (Int32)(object)left[g] : (Int32)(object)right[g];
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (int)(object)left[g] : (int)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64* dataPtr = stackalloc UInt64[Count];
+ ulong* dataPtr = stackalloc ulong[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (UInt64)(object)left[g] : (UInt64)(object)right[g];
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (ulong)(object)left[g] : (ulong)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64* dataPtr = stackalloc Int64[Count];
+ long* dataPtr = stackalloc long[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (Int64)(object)left[g] : (Int64)(object)right[g];
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (long)(object)left[g] : (long)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single* dataPtr = stackalloc Single[Count];
+ float* dataPtr = stackalloc float[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (Single)(object)left[g] : (Single)(object)right[g];
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (float)(object)left[g] : (float)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double* dataPtr = stackalloc Double[Count];
+ double* dataPtr = stackalloc double[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (Double)(object)left[g] : (Double)(object)right[g];
+ dataPtr[g] = ScalarLessThan(left[g], right[g]) ? (double)(object)left[g] : (double)(object)right[g];
}
return new Vector<T>(dataPtr);
}
else
{
Vector<T> vec = new Vector<T>();
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
vec.register.byte_0 = left.register.byte_0 < right.register.byte_0 ? left.register.byte_0 : right.register.byte_0;
vec.register.byte_1 = left.register.byte_1 < right.register.byte_1 ? left.register.byte_1 : right.register.byte_1;
vec.register.byte_15 = left.register.byte_15 < right.register.byte_15 ? left.register.byte_15 : right.register.byte_15;
return vec;
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
vec.register.sbyte_0 = left.register.sbyte_0 < right.register.sbyte_0 ? left.register.sbyte_0 : right.register.sbyte_0;
vec.register.sbyte_1 = left.register.sbyte_1 < right.register.sbyte_1 ? left.register.sbyte_1 : right.register.sbyte_1;
vec.register.sbyte_15 = left.register.sbyte_15 < right.register.sbyte_15 ? left.register.sbyte_15 : right.register.sbyte_15;
return vec;
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
vec.register.uint16_0 = left.register.uint16_0 < right.register.uint16_0 ? left.register.uint16_0 : right.register.uint16_0;
vec.register.uint16_1 = left.register.uint16_1 < right.register.uint16_1 ? left.register.uint16_1 : right.register.uint16_1;
vec.register.uint16_7 = left.register.uint16_7 < right.register.uint16_7 ? left.register.uint16_7 : right.register.uint16_7;
return vec;
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
vec.register.int16_0 = left.register.int16_0 < right.register.int16_0 ? left.register.int16_0 : right.register.int16_0;
vec.register.int16_1 = left.register.int16_1 < right.register.int16_1 ? left.register.int16_1 : right.register.int16_1;
vec.register.int16_7 = left.register.int16_7 < right.register.int16_7 ? left.register.int16_7 : right.register.int16_7;
return vec;
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
vec.register.uint32_0 = left.register.uint32_0 < right.register.uint32_0 ? left.register.uint32_0 : right.register.uint32_0;
vec.register.uint32_1 = left.register.uint32_1 < right.register.uint32_1 ? left.register.uint32_1 : right.register.uint32_1;
vec.register.uint32_3 = left.register.uint32_3 < right.register.uint32_3 ? left.register.uint32_3 : right.register.uint32_3;
return vec;
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
vec.register.int32_0 = left.register.int32_0 < right.register.int32_0 ? left.register.int32_0 : right.register.int32_0;
vec.register.int32_1 = left.register.int32_1 < right.register.int32_1 ? left.register.int32_1 : right.register.int32_1;
vec.register.int32_3 = left.register.int32_3 < right.register.int32_3 ? left.register.int32_3 : right.register.int32_3;
return vec;
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
vec.register.uint64_0 = left.register.uint64_0 < right.register.uint64_0 ? left.register.uint64_0 : right.register.uint64_0;
vec.register.uint64_1 = left.register.uint64_1 < right.register.uint64_1 ? left.register.uint64_1 : right.register.uint64_1;
return vec;
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
vec.register.int64_0 = left.register.int64_0 < right.register.int64_0 ? left.register.int64_0 : right.register.int64_0;
vec.register.int64_1 = left.register.int64_1 < right.register.int64_1 ? left.register.int64_1 : right.register.int64_1;
return vec;
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
vec.register.single_0 = left.register.single_0 < right.register.single_0 ? left.register.single_0 : right.register.single_0;
vec.register.single_1 = left.register.single_1 < right.register.single_1 ? left.register.single_1 : right.register.single_1;
vec.register.single_3 = left.register.single_3 < right.register.single_3 ? left.register.single_3 : right.register.single_3;
return vec;
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
vec.register.double_0 = left.register.double_0 < right.register.double_0 ? left.register.double_0 : right.register.double_0;
vec.register.double_1 = left.register.double_1 < right.register.double_1 ? left.register.double_1 : right.register.double_1;
{
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- Byte* dataPtr = stackalloc Byte[Count];
+ byte* dataPtr = stackalloc byte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (Byte)(object)left[g] : (Byte)(object)right[g];
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (byte)(object)left[g] : (byte)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- SByte* dataPtr = stackalloc SByte[Count];
+ sbyte* dataPtr = stackalloc sbyte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (SByte)(object)left[g] : (SByte)(object)right[g];
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (sbyte)(object)left[g] : (sbyte)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- UInt16* dataPtr = stackalloc UInt16[Count];
+ ushort* dataPtr = stackalloc ushort[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (UInt16)(object)left[g] : (UInt16)(object)right[g];
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (ushort)(object)left[g] : (ushort)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16* dataPtr = stackalloc Int16[Count];
+ short* dataPtr = stackalloc short[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (Int16)(object)left[g] : (Int16)(object)right[g];
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (short)(object)left[g] : (short)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32* dataPtr = stackalloc UInt32[Count];
+ uint* dataPtr = stackalloc uint[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (UInt32)(object)left[g] : (UInt32)(object)right[g];
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (uint)(object)left[g] : (uint)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32* dataPtr = stackalloc Int32[Count];
+ int* dataPtr = stackalloc int[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (Int32)(object)left[g] : (Int32)(object)right[g];
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (int)(object)left[g] : (int)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64* dataPtr = stackalloc UInt64[Count];
+ ulong* dataPtr = stackalloc ulong[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (UInt64)(object)left[g] : (UInt64)(object)right[g];
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (ulong)(object)left[g] : (ulong)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64* dataPtr = stackalloc Int64[Count];
+ long* dataPtr = stackalloc long[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (Int64)(object)left[g] : (Int64)(object)right[g];
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (long)(object)left[g] : (long)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single* dataPtr = stackalloc Single[Count];
+ float* dataPtr = stackalloc float[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (Single)(object)left[g] : (Single)(object)right[g];
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (float)(object)left[g] : (float)(object)right[g];
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double* dataPtr = stackalloc Double[Count];
+ double* dataPtr = stackalloc double[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (Double)(object)left[g] : (Double)(object)right[g];
+ dataPtr[g] = ScalarGreaterThan(left[g], right[g]) ? (double)(object)left[g] : (double)(object)right[g];
}
return new Vector<T>(dataPtr);
}
else
{
Vector<T> vec = new Vector<T>();
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
vec.register.byte_0 = left.register.byte_0 > right.register.byte_0 ? left.register.byte_0 : right.register.byte_0;
vec.register.byte_1 = left.register.byte_1 > right.register.byte_1 ? left.register.byte_1 : right.register.byte_1;
vec.register.byte_15 = left.register.byte_15 > right.register.byte_15 ? left.register.byte_15 : right.register.byte_15;
return vec;
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
vec.register.sbyte_0 = left.register.sbyte_0 > right.register.sbyte_0 ? left.register.sbyte_0 : right.register.sbyte_0;
vec.register.sbyte_1 = left.register.sbyte_1 > right.register.sbyte_1 ? left.register.sbyte_1 : right.register.sbyte_1;
vec.register.sbyte_15 = left.register.sbyte_15 > right.register.sbyte_15 ? left.register.sbyte_15 : right.register.sbyte_15;
return vec;
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
vec.register.uint16_0 = left.register.uint16_0 > right.register.uint16_0 ? left.register.uint16_0 : right.register.uint16_0;
vec.register.uint16_1 = left.register.uint16_1 > right.register.uint16_1 ? left.register.uint16_1 : right.register.uint16_1;
vec.register.uint16_7 = left.register.uint16_7 > right.register.uint16_7 ? left.register.uint16_7 : right.register.uint16_7;
return vec;
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
vec.register.int16_0 = left.register.int16_0 > right.register.int16_0 ? left.register.int16_0 : right.register.int16_0;
vec.register.int16_1 = left.register.int16_1 > right.register.int16_1 ? left.register.int16_1 : right.register.int16_1;
vec.register.int16_7 = left.register.int16_7 > right.register.int16_7 ? left.register.int16_7 : right.register.int16_7;
return vec;
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
vec.register.uint32_0 = left.register.uint32_0 > right.register.uint32_0 ? left.register.uint32_0 : right.register.uint32_0;
vec.register.uint32_1 = left.register.uint32_1 > right.register.uint32_1 ? left.register.uint32_1 : right.register.uint32_1;
vec.register.uint32_3 = left.register.uint32_3 > right.register.uint32_3 ? left.register.uint32_3 : right.register.uint32_3;
return vec;
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
vec.register.int32_0 = left.register.int32_0 > right.register.int32_0 ? left.register.int32_0 : right.register.int32_0;
vec.register.int32_1 = left.register.int32_1 > right.register.int32_1 ? left.register.int32_1 : right.register.int32_1;
vec.register.int32_3 = left.register.int32_3 > right.register.int32_3 ? left.register.int32_3 : right.register.int32_3;
return vec;
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
vec.register.uint64_0 = left.register.uint64_0 > right.register.uint64_0 ? left.register.uint64_0 : right.register.uint64_0;
vec.register.uint64_1 = left.register.uint64_1 > right.register.uint64_1 ? left.register.uint64_1 : right.register.uint64_1;
return vec;
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
vec.register.int64_0 = left.register.int64_0 > right.register.int64_0 ? left.register.int64_0 : right.register.int64_0;
vec.register.int64_1 = left.register.int64_1 > right.register.int64_1 ? left.register.int64_1 : right.register.int64_1;
return vec;
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
vec.register.single_0 = left.register.single_0 > right.register.single_0 ? left.register.single_0 : right.register.single_0;
vec.register.single_1 = left.register.single_1 > right.register.single_1 ? left.register.single_1 : right.register.single_1;
vec.register.single_3 = left.register.single_3 > right.register.single_3 ? left.register.single_3 : right.register.single_3;
return vec;
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
vec.register.double_0 = left.register.double_0 > right.register.double_0 ? left.register.double_0 : right.register.double_0;
vec.register.double_1 = left.register.double_1 > right.register.double_1 ? left.register.double_1 : right.register.double_1;
}
else
{
- if (typeof(T) == typeof(Byte))
- {
- Byte product = 0;
- product += (Byte)(left.register.byte_0 * right.register.byte_0);
- product += (Byte)(left.register.byte_1 * right.register.byte_1);
- product += (Byte)(left.register.byte_2 * right.register.byte_2);
- product += (Byte)(left.register.byte_3 * right.register.byte_3);
- product += (Byte)(left.register.byte_4 * right.register.byte_4);
- product += (Byte)(left.register.byte_5 * right.register.byte_5);
- product += (Byte)(left.register.byte_6 * right.register.byte_6);
- product += (Byte)(left.register.byte_7 * right.register.byte_7);
- product += (Byte)(left.register.byte_8 * right.register.byte_8);
- product += (Byte)(left.register.byte_9 * right.register.byte_9);
- product += (Byte)(left.register.byte_10 * right.register.byte_10);
- product += (Byte)(left.register.byte_11 * right.register.byte_11);
- product += (Byte)(left.register.byte_12 * right.register.byte_12);
- product += (Byte)(left.register.byte_13 * right.register.byte_13);
- product += (Byte)(left.register.byte_14 * right.register.byte_14);
- product += (Byte)(left.register.byte_15 * right.register.byte_15);
+ if (typeof(T) == typeof(byte))
+ {
+ byte product = 0;
+ product += (byte)(left.register.byte_0 * right.register.byte_0);
+ product += (byte)(left.register.byte_1 * right.register.byte_1);
+ product += (byte)(left.register.byte_2 * right.register.byte_2);
+ product += (byte)(left.register.byte_3 * right.register.byte_3);
+ product += (byte)(left.register.byte_4 * right.register.byte_4);
+ product += (byte)(left.register.byte_5 * right.register.byte_5);
+ product += (byte)(left.register.byte_6 * right.register.byte_6);
+ product += (byte)(left.register.byte_7 * right.register.byte_7);
+ product += (byte)(left.register.byte_8 * right.register.byte_8);
+ product += (byte)(left.register.byte_9 * right.register.byte_9);
+ product += (byte)(left.register.byte_10 * right.register.byte_10);
+ product += (byte)(left.register.byte_11 * right.register.byte_11);
+ product += (byte)(left.register.byte_12 * right.register.byte_12);
+ product += (byte)(left.register.byte_13 * right.register.byte_13);
+ product += (byte)(left.register.byte_14 * right.register.byte_14);
+ product += (byte)(left.register.byte_15 * right.register.byte_15);
return (T)(object)product;
}
- else if (typeof(T) == typeof(SByte))
- {
- SByte product = 0;
- product += (SByte)(left.register.sbyte_0 * right.register.sbyte_0);
- product += (SByte)(left.register.sbyte_1 * right.register.sbyte_1);
- product += (SByte)(left.register.sbyte_2 * right.register.sbyte_2);
- product += (SByte)(left.register.sbyte_3 * right.register.sbyte_3);
- product += (SByte)(left.register.sbyte_4 * right.register.sbyte_4);
- product += (SByte)(left.register.sbyte_5 * right.register.sbyte_5);
- product += (SByte)(left.register.sbyte_6 * right.register.sbyte_6);
- product += (SByte)(left.register.sbyte_7 * right.register.sbyte_7);
- product += (SByte)(left.register.sbyte_8 * right.register.sbyte_8);
- product += (SByte)(left.register.sbyte_9 * right.register.sbyte_9);
- product += (SByte)(left.register.sbyte_10 * right.register.sbyte_10);
- product += (SByte)(left.register.sbyte_11 * right.register.sbyte_11);
- product += (SByte)(left.register.sbyte_12 * right.register.sbyte_12);
- product += (SByte)(left.register.sbyte_13 * right.register.sbyte_13);
- product += (SByte)(left.register.sbyte_14 * right.register.sbyte_14);
- product += (SByte)(left.register.sbyte_15 * right.register.sbyte_15);
+ else if (typeof(T) == typeof(sbyte))
+ {
+ sbyte product = 0;
+ product += (sbyte)(left.register.sbyte_0 * right.register.sbyte_0);
+ product += (sbyte)(left.register.sbyte_1 * right.register.sbyte_1);
+ product += (sbyte)(left.register.sbyte_2 * right.register.sbyte_2);
+ product += (sbyte)(left.register.sbyte_3 * right.register.sbyte_3);
+ product += (sbyte)(left.register.sbyte_4 * right.register.sbyte_4);
+ product += (sbyte)(left.register.sbyte_5 * right.register.sbyte_5);
+ product += (sbyte)(left.register.sbyte_6 * right.register.sbyte_6);
+ product += (sbyte)(left.register.sbyte_7 * right.register.sbyte_7);
+ product += (sbyte)(left.register.sbyte_8 * right.register.sbyte_8);
+ product += (sbyte)(left.register.sbyte_9 * right.register.sbyte_9);
+ product += (sbyte)(left.register.sbyte_10 * right.register.sbyte_10);
+ product += (sbyte)(left.register.sbyte_11 * right.register.sbyte_11);
+ product += (sbyte)(left.register.sbyte_12 * right.register.sbyte_12);
+ product += (sbyte)(left.register.sbyte_13 * right.register.sbyte_13);
+ product += (sbyte)(left.register.sbyte_14 * right.register.sbyte_14);
+ product += (sbyte)(left.register.sbyte_15 * right.register.sbyte_15);
return (T)(object)product;
}
- else if (typeof(T) == typeof(UInt16))
- {
- UInt16 product = 0;
- product += (UInt16)(left.register.uint16_0 * right.register.uint16_0);
- product += (UInt16)(left.register.uint16_1 * right.register.uint16_1);
- product += (UInt16)(left.register.uint16_2 * right.register.uint16_2);
- product += (UInt16)(left.register.uint16_3 * right.register.uint16_3);
- product += (UInt16)(left.register.uint16_4 * right.register.uint16_4);
- product += (UInt16)(left.register.uint16_5 * right.register.uint16_5);
- product += (UInt16)(left.register.uint16_6 * right.register.uint16_6);
- product += (UInt16)(left.register.uint16_7 * right.register.uint16_7);
+ else if (typeof(T) == typeof(ushort))
+ {
+ ushort product = 0;
+ product += (ushort)(left.register.uint16_0 * right.register.uint16_0);
+ product += (ushort)(left.register.uint16_1 * right.register.uint16_1);
+ product += (ushort)(left.register.uint16_2 * right.register.uint16_2);
+ product += (ushort)(left.register.uint16_3 * right.register.uint16_3);
+ product += (ushort)(left.register.uint16_4 * right.register.uint16_4);
+ product += (ushort)(left.register.uint16_5 * right.register.uint16_5);
+ product += (ushort)(left.register.uint16_6 * right.register.uint16_6);
+ product += (ushort)(left.register.uint16_7 * right.register.uint16_7);
return (T)(object)product;
}
- else if (typeof(T) == typeof(Int16))
- {
- Int16 product = 0;
- product += (Int16)(left.register.int16_0 * right.register.int16_0);
- product += (Int16)(left.register.int16_1 * right.register.int16_1);
- product += (Int16)(left.register.int16_2 * right.register.int16_2);
- product += (Int16)(left.register.int16_3 * right.register.int16_3);
- product += (Int16)(left.register.int16_4 * right.register.int16_4);
- product += (Int16)(left.register.int16_5 * right.register.int16_5);
- product += (Int16)(left.register.int16_6 * right.register.int16_6);
- product += (Int16)(left.register.int16_7 * right.register.int16_7);
+ else if (typeof(T) == typeof(short))
+ {
+ short product = 0;
+ product += (short)(left.register.int16_0 * right.register.int16_0);
+ product += (short)(left.register.int16_1 * right.register.int16_1);
+ product += (short)(left.register.int16_2 * right.register.int16_2);
+ product += (short)(left.register.int16_3 * right.register.int16_3);
+ product += (short)(left.register.int16_4 * right.register.int16_4);
+ product += (short)(left.register.int16_5 * right.register.int16_5);
+ product += (short)(left.register.int16_6 * right.register.int16_6);
+ product += (short)(left.register.int16_7 * right.register.int16_7);
return (T)(object)product;
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32 product = 0;
- product += (UInt32)(left.register.uint32_0 * right.register.uint32_0);
- product += (UInt32)(left.register.uint32_1 * right.register.uint32_1);
- product += (UInt32)(left.register.uint32_2 * right.register.uint32_2);
- product += (UInt32)(left.register.uint32_3 * right.register.uint32_3);
+ uint product = 0;
+ product += (uint)(left.register.uint32_0 * right.register.uint32_0);
+ product += (uint)(left.register.uint32_1 * right.register.uint32_1);
+ product += (uint)(left.register.uint32_2 * right.register.uint32_2);
+ product += (uint)(left.register.uint32_3 * right.register.uint32_3);
return (T)(object)product;
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32 product = 0;
- product += (Int32)(left.register.int32_0 * right.register.int32_0);
- product += (Int32)(left.register.int32_1 * right.register.int32_1);
- product += (Int32)(left.register.int32_2 * right.register.int32_2);
- product += (Int32)(left.register.int32_3 * right.register.int32_3);
+ int product = 0;
+ product += (int)(left.register.int32_0 * right.register.int32_0);
+ product += (int)(left.register.int32_1 * right.register.int32_1);
+ product += (int)(left.register.int32_2 * right.register.int32_2);
+ product += (int)(left.register.int32_3 * right.register.int32_3);
return (T)(object)product;
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64 product = 0;
- product += (UInt64)(left.register.uint64_0 * right.register.uint64_0);
- product += (UInt64)(left.register.uint64_1 * right.register.uint64_1);
+ ulong product = 0;
+ product += (ulong)(left.register.uint64_0 * right.register.uint64_0);
+ product += (ulong)(left.register.uint64_1 * right.register.uint64_1);
return (T)(object)product;
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64 product = 0;
- product += (Int64)(left.register.int64_0 * right.register.int64_0);
- product += (Int64)(left.register.int64_1 * right.register.int64_1);
+ long product = 0;
+ product += (long)(left.register.int64_0 * right.register.int64_0);
+ product += (long)(left.register.int64_1 * right.register.int64_1);
return (T)(object)product;
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single product = 0;
- product += (Single)(left.register.single_0 * right.register.single_0);
- product += (Single)(left.register.single_1 * right.register.single_1);
- product += (Single)(left.register.single_2 * right.register.single_2);
- product += (Single)(left.register.single_3 * right.register.single_3);
+ float product = 0;
+ product += (float)(left.register.single_0 * right.register.single_0);
+ product += (float)(left.register.single_1 * right.register.single_1);
+ product += (float)(left.register.single_2 * right.register.single_2);
+ product += (float)(left.register.single_3 * right.register.single_3);
return (T)(object)product;
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double product = 0;
- product += (Double)(left.register.double_0 * right.register.double_0);
- product += (Double)(left.register.double_1 * right.register.double_1);
+ double product = 0;
+ product += (double)(left.register.double_0 * right.register.double_0);
+ product += (double)(left.register.double_1 * right.register.double_1);
return (T)(object)product;
}
else
{
if (Vector.IsHardwareAccelerated)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- Byte* dataPtr = stackalloc Byte[Count];
+ byte* dataPtr = stackalloc byte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = unchecked((Byte)Math.Sqrt((Byte)(object)value[g]));
+ dataPtr[g] = unchecked((byte)Math.Sqrt((byte)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- SByte* dataPtr = stackalloc SByte[Count];
+ sbyte* dataPtr = stackalloc sbyte[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = unchecked((SByte)Math.Sqrt((SByte)(object)value[g]));
+ dataPtr[g] = unchecked((sbyte)Math.Sqrt((sbyte)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- UInt16* dataPtr = stackalloc UInt16[Count];
+ ushort* dataPtr = stackalloc ushort[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = unchecked((UInt16)Math.Sqrt((UInt16)(object)value[g]));
+ dataPtr[g] = unchecked((ushort)Math.Sqrt((ushort)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16* dataPtr = stackalloc Int16[Count];
+ short* dataPtr = stackalloc short[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = unchecked((Int16)Math.Sqrt((Int16)(object)value[g]));
+ dataPtr[g] = unchecked((short)Math.Sqrt((short)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32* dataPtr = stackalloc UInt32[Count];
+ uint* dataPtr = stackalloc uint[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = unchecked((UInt32)Math.Sqrt((UInt32)(object)value[g]));
+ dataPtr[g] = unchecked((uint)Math.Sqrt((uint)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32* dataPtr = stackalloc Int32[Count];
+ int* dataPtr = stackalloc int[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = unchecked((Int32)Math.Sqrt((Int32)(object)value[g]));
+ dataPtr[g] = unchecked((int)Math.Sqrt((int)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64* dataPtr = stackalloc UInt64[Count];
+ ulong* dataPtr = stackalloc ulong[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = unchecked((UInt64)Math.Sqrt((UInt64)(object)value[g]));
+ dataPtr[g] = unchecked((ulong)Math.Sqrt((ulong)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64* dataPtr = stackalloc Int64[Count];
+ long* dataPtr = stackalloc long[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = unchecked((Int64)Math.Sqrt((Int64)(object)value[g]));
+ dataPtr[g] = unchecked((long)Math.Sqrt((long)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single* dataPtr = stackalloc Single[Count];
+ float* dataPtr = stackalloc float[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = unchecked((Single)Math.Sqrt((Single)(object)value[g]));
+ dataPtr[g] = unchecked((float)Math.Sqrt((float)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double* dataPtr = stackalloc Double[Count];
+ double* dataPtr = stackalloc double[Count];
for (int g = 0; g < Count; g++)
{
- dataPtr[g] = unchecked((Double)Math.Sqrt((Double)(object)value[g]));
+ dataPtr[g] = unchecked((double)Math.Sqrt((double)(object)value[g]));
}
return new Vector<T>(dataPtr);
}
}
else
{
- if (typeof(T) == typeof(Byte))
- {
- value.register.byte_0 = (Byte)Math.Sqrt(value.register.byte_0);
- value.register.byte_1 = (Byte)Math.Sqrt(value.register.byte_1);
- value.register.byte_2 = (Byte)Math.Sqrt(value.register.byte_2);
- value.register.byte_3 = (Byte)Math.Sqrt(value.register.byte_3);
- value.register.byte_4 = (Byte)Math.Sqrt(value.register.byte_4);
- value.register.byte_5 = (Byte)Math.Sqrt(value.register.byte_5);
- value.register.byte_6 = (Byte)Math.Sqrt(value.register.byte_6);
- value.register.byte_7 = (Byte)Math.Sqrt(value.register.byte_7);
- value.register.byte_8 = (Byte)Math.Sqrt(value.register.byte_8);
- value.register.byte_9 = (Byte)Math.Sqrt(value.register.byte_9);
- value.register.byte_10 = (Byte)Math.Sqrt(value.register.byte_10);
- value.register.byte_11 = (Byte)Math.Sqrt(value.register.byte_11);
- value.register.byte_12 = (Byte)Math.Sqrt(value.register.byte_12);
- value.register.byte_13 = (Byte)Math.Sqrt(value.register.byte_13);
- value.register.byte_14 = (Byte)Math.Sqrt(value.register.byte_14);
- value.register.byte_15 = (Byte)Math.Sqrt(value.register.byte_15);
+ if (typeof(T) == typeof(byte))
+ {
+ value.register.byte_0 = (byte)Math.Sqrt(value.register.byte_0);
+ value.register.byte_1 = (byte)Math.Sqrt(value.register.byte_1);
+ value.register.byte_2 = (byte)Math.Sqrt(value.register.byte_2);
+ value.register.byte_3 = (byte)Math.Sqrt(value.register.byte_3);
+ value.register.byte_4 = (byte)Math.Sqrt(value.register.byte_4);
+ value.register.byte_5 = (byte)Math.Sqrt(value.register.byte_5);
+ value.register.byte_6 = (byte)Math.Sqrt(value.register.byte_6);
+ value.register.byte_7 = (byte)Math.Sqrt(value.register.byte_7);
+ value.register.byte_8 = (byte)Math.Sqrt(value.register.byte_8);
+ value.register.byte_9 = (byte)Math.Sqrt(value.register.byte_9);
+ value.register.byte_10 = (byte)Math.Sqrt(value.register.byte_10);
+ value.register.byte_11 = (byte)Math.Sqrt(value.register.byte_11);
+ value.register.byte_12 = (byte)Math.Sqrt(value.register.byte_12);
+ value.register.byte_13 = (byte)Math.Sqrt(value.register.byte_13);
+ value.register.byte_14 = (byte)Math.Sqrt(value.register.byte_14);
+ value.register.byte_15 = (byte)Math.Sqrt(value.register.byte_15);
return value;
}
- else if (typeof(T) == typeof(SByte))
- {
- value.register.sbyte_0 = (SByte)Math.Sqrt(value.register.sbyte_0);
- value.register.sbyte_1 = (SByte)Math.Sqrt(value.register.sbyte_1);
- value.register.sbyte_2 = (SByte)Math.Sqrt(value.register.sbyte_2);
- value.register.sbyte_3 = (SByte)Math.Sqrt(value.register.sbyte_3);
- value.register.sbyte_4 = (SByte)Math.Sqrt(value.register.sbyte_4);
- value.register.sbyte_5 = (SByte)Math.Sqrt(value.register.sbyte_5);
- value.register.sbyte_6 = (SByte)Math.Sqrt(value.register.sbyte_6);
- value.register.sbyte_7 = (SByte)Math.Sqrt(value.register.sbyte_7);
- value.register.sbyte_8 = (SByte)Math.Sqrt(value.register.sbyte_8);
- value.register.sbyte_9 = (SByte)Math.Sqrt(value.register.sbyte_9);
- value.register.sbyte_10 = (SByte)Math.Sqrt(value.register.sbyte_10);
- value.register.sbyte_11 = (SByte)Math.Sqrt(value.register.sbyte_11);
- value.register.sbyte_12 = (SByte)Math.Sqrt(value.register.sbyte_12);
- value.register.sbyte_13 = (SByte)Math.Sqrt(value.register.sbyte_13);
- value.register.sbyte_14 = (SByte)Math.Sqrt(value.register.sbyte_14);
- value.register.sbyte_15 = (SByte)Math.Sqrt(value.register.sbyte_15);
+ else if (typeof(T) == typeof(sbyte))
+ {
+ value.register.sbyte_0 = (sbyte)Math.Sqrt(value.register.sbyte_0);
+ value.register.sbyte_1 = (sbyte)Math.Sqrt(value.register.sbyte_1);
+ value.register.sbyte_2 = (sbyte)Math.Sqrt(value.register.sbyte_2);
+ value.register.sbyte_3 = (sbyte)Math.Sqrt(value.register.sbyte_3);
+ value.register.sbyte_4 = (sbyte)Math.Sqrt(value.register.sbyte_4);
+ value.register.sbyte_5 = (sbyte)Math.Sqrt(value.register.sbyte_5);
+ value.register.sbyte_6 = (sbyte)Math.Sqrt(value.register.sbyte_6);
+ value.register.sbyte_7 = (sbyte)Math.Sqrt(value.register.sbyte_7);
+ value.register.sbyte_8 = (sbyte)Math.Sqrt(value.register.sbyte_8);
+ value.register.sbyte_9 = (sbyte)Math.Sqrt(value.register.sbyte_9);
+ value.register.sbyte_10 = (sbyte)Math.Sqrt(value.register.sbyte_10);
+ value.register.sbyte_11 = (sbyte)Math.Sqrt(value.register.sbyte_11);
+ value.register.sbyte_12 = (sbyte)Math.Sqrt(value.register.sbyte_12);
+ value.register.sbyte_13 = (sbyte)Math.Sqrt(value.register.sbyte_13);
+ value.register.sbyte_14 = (sbyte)Math.Sqrt(value.register.sbyte_14);
+ value.register.sbyte_15 = (sbyte)Math.Sqrt(value.register.sbyte_15);
return value;
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- value.register.uint16_0 = (UInt16)Math.Sqrt(value.register.uint16_0);
- value.register.uint16_1 = (UInt16)Math.Sqrt(value.register.uint16_1);
- value.register.uint16_2 = (UInt16)Math.Sqrt(value.register.uint16_2);
- value.register.uint16_3 = (UInt16)Math.Sqrt(value.register.uint16_3);
- value.register.uint16_4 = (UInt16)Math.Sqrt(value.register.uint16_4);
- value.register.uint16_5 = (UInt16)Math.Sqrt(value.register.uint16_5);
- value.register.uint16_6 = (UInt16)Math.Sqrt(value.register.uint16_6);
- value.register.uint16_7 = (UInt16)Math.Sqrt(value.register.uint16_7);
+ value.register.uint16_0 = (ushort)Math.Sqrt(value.register.uint16_0);
+ value.register.uint16_1 = (ushort)Math.Sqrt(value.register.uint16_1);
+ value.register.uint16_2 = (ushort)Math.Sqrt(value.register.uint16_2);
+ value.register.uint16_3 = (ushort)Math.Sqrt(value.register.uint16_3);
+ value.register.uint16_4 = (ushort)Math.Sqrt(value.register.uint16_4);
+ value.register.uint16_5 = (ushort)Math.Sqrt(value.register.uint16_5);
+ value.register.uint16_6 = (ushort)Math.Sqrt(value.register.uint16_6);
+ value.register.uint16_7 = (ushort)Math.Sqrt(value.register.uint16_7);
return value;
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- value.register.int16_0 = (Int16)Math.Sqrt(value.register.int16_0);
- value.register.int16_1 = (Int16)Math.Sqrt(value.register.int16_1);
- value.register.int16_2 = (Int16)Math.Sqrt(value.register.int16_2);
- value.register.int16_3 = (Int16)Math.Sqrt(value.register.int16_3);
- value.register.int16_4 = (Int16)Math.Sqrt(value.register.int16_4);
- value.register.int16_5 = (Int16)Math.Sqrt(value.register.int16_5);
- value.register.int16_6 = (Int16)Math.Sqrt(value.register.int16_6);
- value.register.int16_7 = (Int16)Math.Sqrt(value.register.int16_7);
+ value.register.int16_0 = (short)Math.Sqrt(value.register.int16_0);
+ value.register.int16_1 = (short)Math.Sqrt(value.register.int16_1);
+ value.register.int16_2 = (short)Math.Sqrt(value.register.int16_2);
+ value.register.int16_3 = (short)Math.Sqrt(value.register.int16_3);
+ value.register.int16_4 = (short)Math.Sqrt(value.register.int16_4);
+ value.register.int16_5 = (short)Math.Sqrt(value.register.int16_5);
+ value.register.int16_6 = (short)Math.Sqrt(value.register.int16_6);
+ value.register.int16_7 = (short)Math.Sqrt(value.register.int16_7);
return value;
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- value.register.uint32_0 = (UInt32)Math.Sqrt(value.register.uint32_0);
- value.register.uint32_1 = (UInt32)Math.Sqrt(value.register.uint32_1);
- value.register.uint32_2 = (UInt32)Math.Sqrt(value.register.uint32_2);
- value.register.uint32_3 = (UInt32)Math.Sqrt(value.register.uint32_3);
+ value.register.uint32_0 = (uint)Math.Sqrt(value.register.uint32_0);
+ value.register.uint32_1 = (uint)Math.Sqrt(value.register.uint32_1);
+ value.register.uint32_2 = (uint)Math.Sqrt(value.register.uint32_2);
+ value.register.uint32_3 = (uint)Math.Sqrt(value.register.uint32_3);
return value;
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- value.register.int32_0 = (Int32)Math.Sqrt(value.register.int32_0);
- value.register.int32_1 = (Int32)Math.Sqrt(value.register.int32_1);
- value.register.int32_2 = (Int32)Math.Sqrt(value.register.int32_2);
- value.register.int32_3 = (Int32)Math.Sqrt(value.register.int32_3);
+ value.register.int32_0 = (int)Math.Sqrt(value.register.int32_0);
+ value.register.int32_1 = (int)Math.Sqrt(value.register.int32_1);
+ value.register.int32_2 = (int)Math.Sqrt(value.register.int32_2);
+ value.register.int32_3 = (int)Math.Sqrt(value.register.int32_3);
return value;
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- value.register.uint64_0 = (UInt64)Math.Sqrt(value.register.uint64_0);
- value.register.uint64_1 = (UInt64)Math.Sqrt(value.register.uint64_1);
+ value.register.uint64_0 = (ulong)Math.Sqrt(value.register.uint64_0);
+ value.register.uint64_1 = (ulong)Math.Sqrt(value.register.uint64_1);
return value;
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- value.register.int64_0 = (Int64)Math.Sqrt(value.register.int64_0);
- value.register.int64_1 = (Int64)Math.Sqrt(value.register.int64_1);
+ value.register.int64_0 = (long)Math.Sqrt(value.register.int64_0);
+ value.register.int64_1 = (long)Math.Sqrt(value.register.int64_1);
return value;
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- value.register.single_0 = (Single)Math.Sqrt(value.register.single_0);
- value.register.single_1 = (Single)Math.Sqrt(value.register.single_1);
- value.register.single_2 = (Single)Math.Sqrt(value.register.single_2);
- value.register.single_3 = (Single)Math.Sqrt(value.register.single_3);
+ value.register.single_0 = (float)Math.Sqrt(value.register.single_0);
+ value.register.single_1 = (float)Math.Sqrt(value.register.single_1);
+ value.register.single_2 = (float)Math.Sqrt(value.register.single_2);
+ value.register.single_3 = (float)Math.Sqrt(value.register.single_3);
return value;
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- value.register.double_0 = (Double)Math.Sqrt(value.register.double_0);
- value.register.double_1 = (Double)Math.Sqrt(value.register.double_1);
+ value.register.double_0 = (double)Math.Sqrt(value.register.double_0);
+ value.register.double_1 = (double)Math.Sqrt(value.register.double_1);
return value;
}
else
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
private static bool ScalarEquals(T left, T right)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- return (Byte)(object)left == (Byte)(object)right;
+ return (byte)(object)left == (byte)(object)right;
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- return (SByte)(object)left == (SByte)(object)right;
+ return (sbyte)(object)left == (sbyte)(object)right;
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- return (UInt16)(object)left == (UInt16)(object)right;
+ return (ushort)(object)left == (ushort)(object)right;
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- return (Int16)(object)left == (Int16)(object)right;
+ return (short)(object)left == (short)(object)right;
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- return (UInt32)(object)left == (UInt32)(object)right;
+ return (uint)(object)left == (uint)(object)right;
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- return (Int32)(object)left == (Int32)(object)right;
+ return (int)(object)left == (int)(object)right;
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- return (UInt64)(object)left == (UInt64)(object)right;
+ return (ulong)(object)left == (ulong)(object)right;
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- return (Int64)(object)left == (Int64)(object)right;
+ return (long)(object)left == (long)(object)right;
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- return (Single)(object)left == (Single)(object)right;
+ return (float)(object)left == (float)(object)right;
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- return (Double)(object)left == (Double)(object)right;
+ return (double)(object)left == (double)(object)right;
}
else
{
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
private static bool ScalarLessThan(T left, T right)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- return (Byte)(object)left < (Byte)(object)right;
+ return (byte)(object)left < (byte)(object)right;
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- return (SByte)(object)left < (SByte)(object)right;
+ return (sbyte)(object)left < (sbyte)(object)right;
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- return (UInt16)(object)left < (UInt16)(object)right;
+ return (ushort)(object)left < (ushort)(object)right;
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- return (Int16)(object)left < (Int16)(object)right;
+ return (short)(object)left < (short)(object)right;
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- return (UInt32)(object)left < (UInt32)(object)right;
+ return (uint)(object)left < (uint)(object)right;
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- return (Int32)(object)left < (Int32)(object)right;
+ return (int)(object)left < (int)(object)right;
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- return (UInt64)(object)left < (UInt64)(object)right;
+ return (ulong)(object)left < (ulong)(object)right;
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- return (Int64)(object)left < (Int64)(object)right;
+ return (long)(object)left < (long)(object)right;
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- return (Single)(object)left < (Single)(object)right;
+ return (float)(object)left < (float)(object)right;
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- return (Double)(object)left < (Double)(object)right;
+ return (double)(object)left < (double)(object)right;
}
else
{
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
private static bool ScalarGreaterThan(T left, T right)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- return (Byte)(object)left > (Byte)(object)right;
+ return (byte)(object)left > (byte)(object)right;
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- return (SByte)(object)left > (SByte)(object)right;
+ return (sbyte)(object)left > (sbyte)(object)right;
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- return (UInt16)(object)left > (UInt16)(object)right;
+ return (ushort)(object)left > (ushort)(object)right;
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- return (Int16)(object)left > (Int16)(object)right;
+ return (short)(object)left > (short)(object)right;
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- return (UInt32)(object)left > (UInt32)(object)right;
+ return (uint)(object)left > (uint)(object)right;
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- return (Int32)(object)left > (Int32)(object)right;
+ return (int)(object)left > (int)(object)right;
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- return (UInt64)(object)left > (UInt64)(object)right;
+ return (ulong)(object)left > (ulong)(object)right;
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- return (Int64)(object)left > (Int64)(object)right;
+ return (long)(object)left > (long)(object)right;
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- return (Single)(object)left > (Single)(object)right;
+ return (float)(object)left > (float)(object)right;
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- return (Double)(object)left > (Double)(object)right;
+ return (double)(object)left > (double)(object)right;
}
else
{
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
private static T ScalarAdd(T left, T right)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- return (T)(object)unchecked((Byte)((Byte)(object)left + (Byte)(object)right));
+ return (T)(object)unchecked((byte)((byte)(object)left + (byte)(object)right));
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- return (T)(object)unchecked((SByte)((SByte)(object)left + (SByte)(object)right));
+ return (T)(object)unchecked((sbyte)((sbyte)(object)left + (sbyte)(object)right));
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- return (T)(object)unchecked((UInt16)((UInt16)(object)left + (UInt16)(object)right));
+ return (T)(object)unchecked((ushort)((ushort)(object)left + (ushort)(object)right));
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- return (T)(object)unchecked((Int16)((Int16)(object)left + (Int16)(object)right));
+ return (T)(object)unchecked((short)((short)(object)left + (short)(object)right));
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- return (T)(object)unchecked((UInt32)((UInt32)(object)left + (UInt32)(object)right));
+ return (T)(object)unchecked((uint)((uint)(object)left + (uint)(object)right));
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- return (T)(object)unchecked((Int32)((Int32)(object)left + (Int32)(object)right));
+ return (T)(object)unchecked((int)((int)(object)left + (int)(object)right));
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- return (T)(object)unchecked((UInt64)((UInt64)(object)left + (UInt64)(object)right));
+ return (T)(object)unchecked((ulong)((ulong)(object)left + (ulong)(object)right));
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- return (T)(object)unchecked((Int64)((Int64)(object)left + (Int64)(object)right));
+ return (T)(object)unchecked((long)((long)(object)left + (long)(object)right));
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- return (T)(object)unchecked((Single)((Single)(object)left + (Single)(object)right));
+ return (T)(object)unchecked((float)((float)(object)left + (float)(object)right));
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- return (T)(object)unchecked((Double)((Double)(object)left + (Double)(object)right));
+ return (T)(object)unchecked((double)((double)(object)left + (double)(object)right));
}
else
{
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
private static T ScalarSubtract(T left, T right)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- return (T)(object)(Byte)((Byte)(object)left - (Byte)(object)right);
+ return (T)(object)(byte)((byte)(object)left - (byte)(object)right);
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- return (T)(object)(SByte)((SByte)(object)left - (SByte)(object)right);
+ return (T)(object)(sbyte)((sbyte)(object)left - (sbyte)(object)right);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- return (T)(object)(UInt16)((UInt16)(object)left - (UInt16)(object)right);
+ return (T)(object)(ushort)((ushort)(object)left - (ushort)(object)right);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- return (T)(object)(Int16)((Int16)(object)left - (Int16)(object)right);
+ return (T)(object)(short)((short)(object)left - (short)(object)right);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- return (T)(object)(UInt32)((UInt32)(object)left - (UInt32)(object)right);
+ return (T)(object)(uint)((uint)(object)left - (uint)(object)right);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- return (T)(object)(Int32)((Int32)(object)left - (Int32)(object)right);
+ return (T)(object)(int)((int)(object)left - (int)(object)right);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- return (T)(object)(UInt64)((UInt64)(object)left - (UInt64)(object)right);
+ return (T)(object)(ulong)((ulong)(object)left - (ulong)(object)right);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- return (T)(object)(Int64)((Int64)(object)left - (Int64)(object)right);
+ return (T)(object)(long)((long)(object)left - (long)(object)right);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- return (T)(object)(Single)((Single)(object)left - (Single)(object)right);
+ return (T)(object)(float)((float)(object)left - (float)(object)right);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- return (T)(object)(Double)((Double)(object)left - (Double)(object)right);
+ return (T)(object)(double)((double)(object)left - (double)(object)right);
}
else
{
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
private static T ScalarMultiply(T left, T right)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- return (T)(object)unchecked((Byte)((Byte)(object)left * (Byte)(object)right));
+ return (T)(object)unchecked((byte)((byte)(object)left * (byte)(object)right));
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- return (T)(object)unchecked((SByte)((SByte)(object)left * (SByte)(object)right));
+ return (T)(object)unchecked((sbyte)((sbyte)(object)left * (sbyte)(object)right));
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- return (T)(object)unchecked((UInt16)((UInt16)(object)left * (UInt16)(object)right));
+ return (T)(object)unchecked((ushort)((ushort)(object)left * (ushort)(object)right));
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- return (T)(object)unchecked((Int16)((Int16)(object)left * (Int16)(object)right));
+ return (T)(object)unchecked((short)((short)(object)left * (short)(object)right));
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- return (T)(object)unchecked((UInt32)((UInt32)(object)left * (UInt32)(object)right));
+ return (T)(object)unchecked((uint)((uint)(object)left * (uint)(object)right));
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- return (T)(object)unchecked((Int32)((Int32)(object)left * (Int32)(object)right));
+ return (T)(object)unchecked((int)((int)(object)left * (int)(object)right));
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- return (T)(object)unchecked((UInt64)((UInt64)(object)left * (UInt64)(object)right));
+ return (T)(object)unchecked((ulong)((ulong)(object)left * (ulong)(object)right));
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- return (T)(object)unchecked((Int64)((Int64)(object)left * (Int64)(object)right));
+ return (T)(object)unchecked((long)((long)(object)left * (long)(object)right));
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- return (T)(object)unchecked((Single)((Single)(object)left * (Single)(object)right));
+ return (T)(object)unchecked((float)((float)(object)left * (float)(object)right));
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- return (T)(object)unchecked((Double)((Double)(object)left * (Double)(object)right));
+ return (T)(object)unchecked((double)((double)(object)left * (double)(object)right));
}
else
{
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
private static T ScalarDivide(T left, T right)
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- return (T)(object)(Byte)((Byte)(object)left / (Byte)(object)right);
+ return (T)(object)(byte)((byte)(object)left / (byte)(object)right);
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- return (T)(object)(SByte)((SByte)(object)left / (SByte)(object)right);
+ return (T)(object)(sbyte)((sbyte)(object)left / (sbyte)(object)right);
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- return (T)(object)(UInt16)((UInt16)(object)left / (UInt16)(object)right);
+ return (T)(object)(ushort)((ushort)(object)left / (ushort)(object)right);
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- return (T)(object)(Int16)((Int16)(object)left / (Int16)(object)right);
+ return (T)(object)(short)((short)(object)left / (short)(object)right);
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- return (T)(object)(UInt32)((UInt32)(object)left / (UInt32)(object)right);
+ return (T)(object)(uint)((uint)(object)left / (uint)(object)right);
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- return (T)(object)(Int32)((Int32)(object)left / (Int32)(object)right);
+ return (T)(object)(int)((int)(object)left / (int)(object)right);
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- return (T)(object)(UInt64)((UInt64)(object)left / (UInt64)(object)right);
+ return (T)(object)(ulong)((ulong)(object)left / (ulong)(object)right);
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- return (T)(object)(Int64)((Int64)(object)left / (Int64)(object)right);
+ return (T)(object)(long)((long)(object)left / (long)(object)right);
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- return (T)(object)(Single)((Single)(object)left / (Single)(object)right);
+ return (T)(object)(float)((float)(object)left / (float)(object)right);
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- return (T)(object)(Double)((Double)(object)left / (Double)(object)right);
+ return (T)(object)(double)((double)(object)left / (double)(object)right);
}
else
{
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
private static T GetOneValue()
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
- Byte value = 1;
+ byte value = 1;
return (T)(object)value;
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
- SByte value = 1;
+ sbyte value = 1;
return (T)(object)value;
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
- UInt16 value = 1;
+ ushort value = 1;
return (T)(object)value;
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
- Int16 value = 1;
+ short value = 1;
return (T)(object)value;
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
- UInt32 value = 1;
+ uint value = 1;
return (T)(object)value;
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
- Int32 value = 1;
+ int value = 1;
return (T)(object)value;
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
- UInt64 value = 1;
+ ulong value = 1;
return (T)(object)value;
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
- Int64 value = 1;
+ long value = 1;
return (T)(object)value;
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
- Single value = 1;
+ float value = 1;
return (T)(object)value;
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
- Double value = 1;
+ double value = 1;
return (T)(object)value;
}
else
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
private static T GetAllBitsSetValue()
{
- if (typeof(T) == typeof(Byte))
+ if (typeof(T) == typeof(byte))
{
return (T)(object)ConstantHelper.GetByteWithAllBitsSet();
}
- else if (typeof(T) == typeof(SByte))
+ else if (typeof(T) == typeof(sbyte))
{
return (T)(object)ConstantHelper.GetSByteWithAllBitsSet();
}
- else if (typeof(T) == typeof(UInt16))
+ else if (typeof(T) == typeof(ushort))
{
return (T)(object)ConstantHelper.GetUInt16WithAllBitsSet();
}
- else if (typeof(T) == typeof(Int16))
+ else if (typeof(T) == typeof(short))
{
return (T)(object)ConstantHelper.GetInt16WithAllBitsSet();
}
- else if (typeof(T) == typeof(UInt32))
+ else if (typeof(T) == typeof(uint))
{
return (T)(object)ConstantHelper.GetUInt32WithAllBitsSet();
}
- else if (typeof(T) == typeof(Int32))
+ else if (typeof(T) == typeof(int))
{
return (T)(object)ConstantHelper.GetInt32WithAllBitsSet();
}
- else if (typeof(T) == typeof(UInt64))
+ else if (typeof(T) == typeof(ulong))
{
return (T)(object)ConstantHelper.GetUInt64WithAllBitsSet();
}
- else if (typeof(T) == typeof(Int64))
+ else if (typeof(T) == typeof(long))
{
return (T)(object)ConstantHelper.GetInt64WithAllBitsSet();
}
- else if (typeof(T) == typeof(Single))
+ else if (typeof(T) == typeof(float))
{
return (T)(object)ConstantHelper.GetSingleWithAllBitsSet();
}
- else if (typeof(T) == typeof(Double))
+ else if (typeof(T) == typeof(double))
{
return (T)(object)ConstantHelper.GetDoubleWithAllBitsSet();
}
/// </summary>
[CLSCompliant(false)]
[Intrinsic]
- public static unsafe void Widen(Vector<Byte> source, out Vector<UInt16> low, out Vector<UInt16> high)
+ public static unsafe void Widen(Vector<byte> source, out Vector<ushort> low, out Vector<ushort> high)
{
- int elements = Vector<Byte>.Count;
- UInt16* lowPtr = stackalloc UInt16[elements / 2];
+ int elements = Vector<byte>.Count;
+ ushort* lowPtr = stackalloc ushort[elements / 2];
for (int i = 0; i < elements / 2; i++)
{
- lowPtr[i] = (UInt16)source[i];
+ lowPtr[i] = (ushort)source[i];
}
- UInt16* highPtr = stackalloc UInt16[elements / 2];
+ ushort* highPtr = stackalloc ushort[elements / 2];
for (int i = 0; i < elements / 2; i++)
{
- highPtr[i] = (UInt16)source[i + (elements / 2)];
+ highPtr[i] = (ushort)source[i + (elements / 2)];
}
- low = new Vector<UInt16>(lowPtr);
- high = new Vector<UInt16>(highPtr);
+ low = new Vector<ushort>(lowPtr);
+ high = new Vector<ushort>(highPtr);
}
/// <summary>
/// </summary>
[CLSCompliant(false)]
[Intrinsic]
- public static unsafe void Widen(Vector<UInt16> source, out Vector<UInt32> low, out Vector<UInt32> high)
+ public static unsafe void Widen(Vector<ushort> source, out Vector<uint> low, out Vector<uint> high)
{
- int elements = Vector<UInt16>.Count;
- UInt32* lowPtr = stackalloc UInt32[elements / 2];
+ int elements = Vector<ushort>.Count;
+ uint* lowPtr = stackalloc uint[elements / 2];
for (int i = 0; i < elements / 2; i++)
{
- lowPtr[i] = (UInt32)source[i];
+ lowPtr[i] = (uint)source[i];
}
- UInt32* highPtr = stackalloc UInt32[elements / 2];
+ uint* highPtr = stackalloc uint[elements / 2];
for (int i = 0; i < elements / 2; i++)
{
- highPtr[i] = (UInt32)source[i + (elements / 2)];
+ highPtr[i] = (uint)source[i + (elements / 2)];
}
- low = new Vector<UInt32>(lowPtr);
- high = new Vector<UInt32>(highPtr);
+ low = new Vector<uint>(lowPtr);
+ high = new Vector<uint>(highPtr);
}
/// <summary>
/// </summary>
[CLSCompliant(false)]
[Intrinsic]
- public static unsafe void Widen(Vector<UInt32> source, out Vector<UInt64> low, out Vector<UInt64> high)
+ public static unsafe void Widen(Vector<uint> source, out Vector<ulong> low, out Vector<ulong> high)
{
- int elements = Vector<UInt32>.Count;
- UInt64* lowPtr = stackalloc UInt64[elements / 2];
+ int elements = Vector<uint>.Count;
+ ulong* lowPtr = stackalloc ulong[elements / 2];
for (int i = 0; i < elements / 2; i++)
{
- lowPtr[i] = (UInt64)source[i];
+ lowPtr[i] = (ulong)source[i];
}
- UInt64* highPtr = stackalloc UInt64[elements / 2];
+ ulong* highPtr = stackalloc ulong[elements / 2];
for (int i = 0; i < elements / 2; i++)
{
- highPtr[i] = (UInt64)source[i + (elements / 2)];
+ highPtr[i] = (ulong)source[i + (elements / 2)];
}
- low = new Vector<UInt64>(lowPtr);
- high = new Vector<UInt64>(highPtr);
+ low = new Vector<ulong>(lowPtr);
+ high = new Vector<ulong>(highPtr);
}
/// <summary>
/// </summary>
[CLSCompliant(false)]
[Intrinsic]
- public static unsafe void Widen(Vector<SByte> source, out Vector<Int16> low, out Vector<Int16> high)
+ public static unsafe void Widen(Vector<sbyte> source, out Vector<short> low, out Vector<short> high)
{
- int elements = Vector<SByte>.Count;
- Int16* lowPtr = stackalloc Int16[elements / 2];
+ int elements = Vector<sbyte>.Count;
+ short* lowPtr = stackalloc short[elements / 2];
for (int i = 0; i < elements / 2; i++)
{
- lowPtr[i] = (Int16)source[i];
+ lowPtr[i] = (short)source[i];
}
- Int16* highPtr = stackalloc Int16[elements / 2];
+ short* highPtr = stackalloc short[elements / 2];
for (int i = 0; i < elements / 2; i++)
{
- highPtr[i] = (Int16)source[i + (elements / 2)];
+ highPtr[i] = (short)source[i + (elements / 2)];
}
- low = new Vector<Int16>(lowPtr);
- high = new Vector<Int16>(highPtr);
+ low = new Vector<short>(lowPtr);
+ high = new Vector<short>(highPtr);
}
/// <summary>
/// <param name="high">The second output vector, whose elements will contain the widened elements from higher indices in the source vector.</param>
/// </summary>
[Intrinsic]
- public static unsafe void Widen(Vector<Int16> source, out Vector<Int32> low, out Vector<Int32> high)
+ public static unsafe void Widen(Vector<short> source, out Vector<int> low, out Vector<int> high)
{
- int elements = Vector<Int16>.Count;
- Int32* lowPtr = stackalloc Int32[elements / 2];
+ int elements = Vector<short>.Count;
+ int* lowPtr = stackalloc int[elements / 2];
for (int i = 0; i < elements / 2; i++)
{
- lowPtr[i] = (Int32)source[i];
+ lowPtr[i] = (int)source[i];
}
- Int32* highPtr = stackalloc Int32[elements / 2];
+ int* highPtr = stackalloc int[elements / 2];
for (int i = 0; i < elements / 2; i++)
{
- highPtr[i] = (Int32)source[i + (elements / 2)];
+ highPtr[i] = (int)source[i + (elements / 2)];
}
- low = new Vector<Int32>(lowPtr);
- high = new Vector<Int32>(highPtr);
+ low = new Vector<int>(lowPtr);
+ high = new Vector<int>(highPtr);
}
/// <summary>
/// <param name="high">The second output vector, whose elements will contain the widened elements from higher indices in the source vector.</param>
/// </summary>
[Intrinsic]
- public static unsafe void Widen(Vector<Int32> source, out Vector<Int64> low, out Vector<Int64> high)
+ public static unsafe void Widen(Vector<int> source, out Vector<long> low, out Vector<long> high)
{
- int elements = Vector<Int32>.Count;
- Int64* lowPtr = stackalloc Int64[elements / 2];
+ int elements = Vector<int>.Count;
+ long* lowPtr = stackalloc long[elements / 2];
for (int i = 0; i < elements / 2; i++)
{
- lowPtr[i] = (Int64)source[i];
+ lowPtr[i] = (long)source[i];
}
- Int64* highPtr = stackalloc Int64[elements / 2];
+ long* highPtr = stackalloc long[elements / 2];
for (int i = 0; i < elements / 2; i++)
{
- highPtr[i] = (Int64)source[i + (elements / 2)];
+ highPtr[i] = (long)source[i + (elements / 2)];
}
- low = new Vector<Int64>(lowPtr);
- high = new Vector<Int64>(highPtr);
+ low = new Vector<long>(lowPtr);
+ high = new Vector<long>(highPtr);
}
/// <summary>
/// <param name="high">The second output vector, whose elements will contain the widened elements from higher indices in the source vector.</param>
/// </summary>
[Intrinsic]
- public static unsafe void Widen(Vector<Single> source, out Vector<Double> low, out Vector<Double> high)
+ public static unsafe void Widen(Vector<float> source, out Vector<double> low, out Vector<double> high)
{
- int elements = Vector<Single>.Count;
- Double* lowPtr = stackalloc Double[elements / 2];
+ int elements = Vector<float>.Count;
+ double* lowPtr = stackalloc double[elements / 2];
for (int i = 0; i < elements / 2; i++)
{
- lowPtr[i] = (Double)source[i];
+ lowPtr[i] = (double)source[i];
}
- Double* highPtr = stackalloc Double[elements / 2];
+ double* highPtr = stackalloc double[elements / 2];
for (int i = 0; i < elements / 2; i++)
{
- highPtr[i] = (Double)source[i + (elements / 2)];
+ highPtr[i] = (double)source[i + (elements / 2)];
}
- low = new Vector<Double>(lowPtr);
- high = new Vector<Double>(highPtr);
+ low = new Vector<double>(lowPtr);
+ high = new Vector<double>(highPtr);
}
/// <summary>
/// </summary>
[CLSCompliant(false)]
[Intrinsic]
- public static unsafe Vector<Byte> Narrow(Vector<UInt16> low, Vector<UInt16> high)
+ public static unsafe Vector<byte> Narrow(Vector<ushort> low, Vector<ushort> high)
{
unchecked
{
- int elements = Vector<Byte>.Count;
- Byte* retPtr = stackalloc Byte[elements];
+ int elements = Vector<byte>.Count;
+ byte* retPtr = stackalloc byte[elements];
for (int i = 0; i < elements / 2; i++)
{
- retPtr[i] = (Byte)low[i];
+ retPtr[i] = (byte)low[i];
}
for (int i = 0; i < elements / 2; i++)
{
- retPtr[i + (elements / 2)] = (Byte)high[i];
+ retPtr[i + (elements / 2)] = (byte)high[i];
}
- return new Vector<Byte>(retPtr);
+ return new Vector<byte>(retPtr);
}
}
/// </summary>
[CLSCompliant(false)]
[Intrinsic]
- public static unsafe Vector<UInt16> Narrow(Vector<UInt32> low, Vector<UInt32> high)
+ public static unsafe Vector<ushort> Narrow(Vector<uint> low, Vector<uint> high)
{
unchecked
{
- int elements = Vector<UInt16>.Count;
- UInt16* retPtr = stackalloc UInt16[elements];
+ int elements = Vector<ushort>.Count;
+ ushort* retPtr = stackalloc ushort[elements];
for (int i = 0; i < elements / 2; i++)
{
- retPtr[i] = (UInt16)low[i];
+ retPtr[i] = (ushort)low[i];
}
for (int i = 0; i < elements / 2; i++)
{
- retPtr[i + (elements / 2)] = (UInt16)high[i];
+ retPtr[i + (elements / 2)] = (ushort)high[i];
}
- return new Vector<UInt16>(retPtr);
+ return new Vector<ushort>(retPtr);
}
}
/// </summary>
[CLSCompliant(false)]
[Intrinsic]
- public static unsafe Vector<UInt32> Narrow(Vector<UInt64> low, Vector<UInt64> high)
+ public static unsafe Vector<uint> Narrow(Vector<ulong> low, Vector<ulong> high)
{
unchecked
{
- int elements = Vector<UInt32>.Count;
- UInt32* retPtr = stackalloc UInt32[elements];
+ int elements = Vector<uint>.Count;
+ uint* retPtr = stackalloc uint[elements];
for (int i = 0; i < elements / 2; i++)
{
- retPtr[i] = (UInt32)low[i];
+ retPtr[i] = (uint)low[i];
}
for (int i = 0; i < elements / 2; i++)
{
- retPtr[i + (elements / 2)] = (UInt32)high[i];
+ retPtr[i + (elements / 2)] = (uint)high[i];
}
- return new Vector<UInt32>(retPtr);
+ return new Vector<uint>(retPtr);
}
}
/// </summary>
[CLSCompliant(false)]
[Intrinsic]
- public static unsafe Vector<SByte> Narrow(Vector<Int16> low, Vector<Int16> high)
+ public static unsafe Vector<sbyte> Narrow(Vector<short> low, Vector<short> high)
{
unchecked
{
- int elements = Vector<SByte>.Count;
- SByte* retPtr = stackalloc SByte[elements];
+ int elements = Vector<sbyte>.Count;
+ sbyte* retPtr = stackalloc sbyte[elements];
for (int i = 0; i < elements / 2; i++)
{
- retPtr[i] = (SByte)low[i];
+ retPtr[i] = (sbyte)low[i];
}
for (int i = 0; i < elements / 2; i++)
{
- retPtr[i + (elements / 2)] = (SByte)high[i];
+ retPtr[i + (elements / 2)] = (sbyte)high[i];
}
- return new Vector<SByte>(retPtr);
+ return new Vector<sbyte>(retPtr);
}
}
/// <returns>A Vector{Int16} containing elements narrowed from the source vectors.</returns>
/// </summary>
[Intrinsic]
- public static unsafe Vector<Int16> Narrow(Vector<Int32> low, Vector<Int32> high)
+ public static unsafe Vector<short> Narrow(Vector<int> low, Vector<int> high)
{
unchecked
{
- int elements = Vector<Int16>.Count;
- Int16* retPtr = stackalloc Int16[elements];
+ int elements = Vector<short>.Count;
+ short* retPtr = stackalloc short[elements];
for (int i = 0; i < elements / 2; i++)
{
- retPtr[i] = (Int16)low[i];
+ retPtr[i] = (short)low[i];
}
for (int i = 0; i < elements / 2; i++)
{
- retPtr[i + (elements / 2)] = (Int16)high[i];
+ retPtr[i + (elements / 2)] = (short)high[i];
}
- return new Vector<Int16>(retPtr);
+ return new Vector<short>(retPtr);
}
}
/// <returns>A Vector{Int32} containing elements narrowed from the source vectors.</returns>
/// </summary>
[Intrinsic]
- public static unsafe Vector<Int32> Narrow(Vector<Int64> low, Vector<Int64> high)
+ public static unsafe Vector<int> Narrow(Vector<long> low, Vector<long> high)
{
unchecked
{
- int elements = Vector<Int32>.Count;
- Int32* retPtr = stackalloc Int32[elements];
+ int elements = Vector<int>.Count;
+ int* retPtr = stackalloc int[elements];
for (int i = 0; i < elements / 2; i++)
{
- retPtr[i] = (Int32)low[i];
+ retPtr[i] = (int)low[i];
}
for (int i = 0; i < elements / 2; i++)
{
- retPtr[i + (elements / 2)] = (Int32)high[i];
+ retPtr[i + (elements / 2)] = (int)high[i];
}
- return new Vector<Int32>(retPtr);
+ return new Vector<int>(retPtr);
}
}
/// <returns>A Vector{Single} containing elements narrowed from the source vectors.</returns>
/// </summary>
[Intrinsic]
- public static unsafe Vector<Single> Narrow(Vector<Double> low, Vector<Double> high)
+ public static unsafe Vector<float> Narrow(Vector<double> low, Vector<double> high)
{
unchecked
{
- int elements = Vector<Single>.Count;
- Single* retPtr = stackalloc Single[elements];
+ int elements = Vector<float>.Count;
+ float* retPtr = stackalloc float[elements];
for (int i = 0; i < elements / 2; i++)
{
- retPtr[i] = (Single)low[i];
+ retPtr[i] = (float)low[i];
}
for (int i = 0; i < elements / 2; i++)
{
- retPtr[i + (elements / 2)] = (Single)high[i];
+ retPtr[i + (elements / 2)] = (float)high[i];
}
- return new Vector<Single>(retPtr);
+ return new Vector<float>(retPtr);
}
}
/// <param name="value">The source vector.</param>
/// <returns>The converted vector.</returns>
[Intrinsic]
- public static unsafe Vector<Single> ConvertToSingle(Vector<Int32> value)
+ public static unsafe Vector<float> ConvertToSingle(Vector<int> value)
{
unchecked
{
- int elements = Vector<Single>.Count;
- Single* retPtr = stackalloc Single[elements];
+ int elements = Vector<float>.Count;
+ float* retPtr = stackalloc float[elements];
for (int i = 0; i < elements; i++)
{
- retPtr[i] = (Single)value[i];
+ retPtr[i] = (float)value[i];
}
- return new Vector<Single>(retPtr);
+ return new Vector<float>(retPtr);
}
}
/// <returns>The converted vector.</returns>
[CLSCompliant(false)]
[Intrinsic]
- public static unsafe Vector<Single> ConvertToSingle(Vector<UInt32> value)
+ public static unsafe Vector<float> ConvertToSingle(Vector<uint> value)
{
unchecked
{
- int elements = Vector<Single>.Count;
- Single* retPtr = stackalloc Single[elements];
+ int elements = Vector<float>.Count;
+ float* retPtr = stackalloc float[elements];
for (int i = 0; i < elements; i++)
{
- retPtr[i] = (Single)value[i];
+ retPtr[i] = (float)value[i];
}
- return new Vector<Single>(retPtr);
+ return new Vector<float>(retPtr);
}
}
/// <param name="value">The source vector.</param>
/// <returns>The converted vector.</returns>
[Intrinsic]
- public static unsafe Vector<Double> ConvertToDouble(Vector<Int64> value)
+ public static unsafe Vector<double> ConvertToDouble(Vector<long> value)
{
unchecked
{
- int elements = Vector<Double>.Count;
- Double* retPtr = stackalloc Double[elements];
+ int elements = Vector<double>.Count;
+ double* retPtr = stackalloc double[elements];
for (int i = 0; i < elements; i++)
{
- retPtr[i] = (Double)value[i];
+ retPtr[i] = (double)value[i];
}
- return new Vector<Double>(retPtr);
+ return new Vector<double>(retPtr);
}
}
/// <returns>The converted vector.</returns>
[CLSCompliant(false)]
[Intrinsic]
- public static unsafe Vector<Double> ConvertToDouble(Vector<UInt64> value)
+ public static unsafe Vector<double> ConvertToDouble(Vector<ulong> value)
{
unchecked
{
- int elements = Vector<Double>.Count;
- Double* retPtr = stackalloc Double[elements];
+ int elements = Vector<double>.Count;
+ double* retPtr = stackalloc double[elements];
for (int i = 0; i < elements; i++)
{
- retPtr[i] = (Double)value[i];
+ retPtr[i] = (double)value[i];
}
- return new Vector<Double>(retPtr);
+ return new Vector<double>(retPtr);
}
}
/// <param name="value">The source vector.</param>
/// <returns>The converted vector.</returns>
[Intrinsic]
- public static unsafe Vector<Int32> ConvertToInt32(Vector<Single> value)
+ public static unsafe Vector<int> ConvertToInt32(Vector<float> value)
{
unchecked
{
- int elements = Vector<Int32>.Count;
- Int32* retPtr = stackalloc Int32[elements];
+ int elements = Vector<int>.Count;
+ int* retPtr = stackalloc int[elements];
for (int i = 0; i < elements; i++)
{
- retPtr[i] = (Int32)value[i];
+ retPtr[i] = (int)value[i];
}
- return new Vector<Int32>(retPtr);
+ return new Vector<int>(retPtr);
}
}
/// <returns>The converted vector.</returns>
[CLSCompliant(false)]
[Intrinsic]
- public static unsafe Vector<UInt32> ConvertToUInt32(Vector<Single> value)
+ public static unsafe Vector<uint> ConvertToUInt32(Vector<float> value)
{
unchecked
{
- int elements = Vector<UInt32>.Count;
- UInt32* retPtr = stackalloc UInt32[elements];
+ int elements = Vector<uint>.Count;
+ uint* retPtr = stackalloc uint[elements];
for (int i = 0; i < elements; i++)
{
- retPtr[i] = (UInt32)value[i];
+ retPtr[i] = (uint)value[i];
}
- return new Vector<UInt32>(retPtr);
+ return new Vector<uint>(retPtr);
}
}
/// <param name="value">The source vector.</param>
/// <returns>The converted vector.</returns>
[Intrinsic]
- public static unsafe Vector<Int64> ConvertToInt64(Vector<Double> value)
+ public static unsafe Vector<long> ConvertToInt64(Vector<double> value)
{
unchecked
{
- int elements = Vector<Int64>.Count;
- Int64* retPtr = stackalloc Int64[elements];
+ int elements = Vector<long>.Count;
+ long* retPtr = stackalloc long[elements];
for (int i = 0; i < elements; i++)
{
- retPtr[i] = (Int64)value[i];
+ retPtr[i] = (long)value[i];
}
- return new Vector<Int64>(retPtr);
+ return new Vector<long>(retPtr);
}
}
/// <returns>The converted vector.</returns>
[CLSCompliant(false)]
[Intrinsic]
- public static unsafe Vector<UInt64> ConvertToUInt64(Vector<Double> value)
+ public static unsafe Vector<ulong> ConvertToUInt64(Vector<double> value)
{
unchecked
{
- int elements = Vector<UInt64>.Count;
- UInt64* retPtr = stackalloc UInt64[elements];
+ int elements = Vector<ulong>.Count;
+ ulong* retPtr = stackalloc ulong[elements];
for (int i = 0; i < elements; i++)
{
- retPtr[i] = (UInt64)value[i];
+ retPtr[i] = (ulong)value[i];
}
- return new Vector<UInt64>(retPtr);
+ return new Vector<ulong>(retPtr);
}
}
/// <param name="right">The second source vector.</param>
/// <returns>The new vector with elements selected based on the mask.</returns>
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<Single> ConditionalSelect(Vector<int> condition, Vector<Single> left, Vector<Single> right)
+ public static Vector<float> ConditionalSelect(Vector<int> condition, Vector<float> left, Vector<float> right)
{
- return (Vector<Single>)Vector<Single>.ConditionalSelect((Vector<Single>)condition, left, right);
+ return (Vector<float>)Vector<float>.ConditionalSelect((Vector<float>)condition, left, right);
}
/// <summary>
/// <param name="right">The second vector to compare.</param>
/// <returns>The resultant vector.</returns>
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<int> Equals(Vector<Single> left, Vector<Single> right)
+ public static Vector<int> Equals(Vector<float> left, Vector<float> right)
{
- return (Vector<int>)Vector<Single>.Equals(left, right);
+ return (Vector<int>)Vector<float>.Equals(left, right);
}
/// <summary>
/// <param name="right">The second vector to compare.</param>
/// <returns>The resultant integral vector.</returns>
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<int> LessThan(Vector<Single> left, Vector<Single> right)
+ public static Vector<int> LessThan(Vector<float> left, Vector<float> right)
{
- return (Vector<int>)Vector<Single>.LessThan(left, right);
+ return (Vector<int>)Vector<float>.LessThan(left, right);
}
/// <summary>
/// <param name="right">The second vector to compare.</param>
/// <returns>The resultant integral vector.</returns>
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<int> LessThanOrEqual(Vector<Single> left, Vector<Single> right)
+ public static Vector<int> LessThanOrEqual(Vector<float> left, Vector<float> right)
{
- return (Vector<int>)Vector<Single>.LessThanOrEqual(left, right);
+ return (Vector<int>)Vector<float>.LessThanOrEqual(left, right);
}
/// <summary>
/// <param name="right">The second vector to compare.</param>
/// <returns>The resultant integral vector.</returns>
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<int> GreaterThan(Vector<Single> left, Vector<Single> right)
+ public static Vector<int> GreaterThan(Vector<float> left, Vector<float> right)
{
- return (Vector<int>)Vector<Single>.GreaterThan(left, right);
+ return (Vector<int>)Vector<float>.GreaterThan(left, right);
}
/// <summary>
/// <param name="right">The second vector to compare.</param>
/// <returns>The resultant integral vector.</returns>
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<int> GreaterThanOrEqual(Vector<Single> left, Vector<Single> right)
+ public static Vector<int> GreaterThanOrEqual(Vector<float> left, Vector<float> right)
{
- return (Vector<int>)Vector<Single>.GreaterThanOrEqual(left, right);
+ return (Vector<int>)Vector<float>.GreaterThanOrEqual(left, right);
}
/// <summary>
/// <param name="value">The source vector</param>
/// <returns>The reinterpreted vector.</returns>
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<Byte> AsVectorByte<T>(Vector<T> value) where T : struct
+ public static Vector<byte> AsVectorByte<T>(Vector<T> value) where T : struct
{
- return (Vector<Byte>)value;
+ return (Vector<byte>)value;
}
/// <summary>
/// <returns>The reinterpreted vector.</returns>
[CLSCompliant(false)]
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<SByte> AsVectorSByte<T>(Vector<T> value) where T : struct
+ public static Vector<sbyte> AsVectorSByte<T>(Vector<T> value) where T : struct
{
- return (Vector<SByte>)value;
+ return (Vector<sbyte>)value;
}
/// <summary>
/// <returns>The reinterpreted vector.</returns>
[CLSCompliant(false)]
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<UInt16> AsVectorUInt16<T>(Vector<T> value) where T : struct
+ public static Vector<ushort> AsVectorUInt16<T>(Vector<T> value) where T : struct
{
- return (Vector<UInt16>)value;
+ return (Vector<ushort>)value;
}
/// <summary>
/// <param name="value">The source vector</param>
/// <returns>The reinterpreted vector.</returns>
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<Int16> AsVectorInt16<T>(Vector<T> value) where T : struct
+ public static Vector<short> AsVectorInt16<T>(Vector<T> value) where T : struct
{
- return (Vector<Int16>)value;
+ return (Vector<short>)value;
}
/// <summary>
/// <returns>The reinterpreted vector.</returns>
[CLSCompliant(false)]
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<UInt32> AsVectorUInt32<T>(Vector<T> value) where T : struct
+ public static Vector<uint> AsVectorUInt32<T>(Vector<T> value) where T : struct
{
- return (Vector<UInt32>)value;
+ return (Vector<uint>)value;
}
/// <summary>
/// <param name="value">The source vector</param>
/// <returns>The reinterpreted vector.</returns>
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<Int32> AsVectorInt32<T>(Vector<T> value) where T : struct
+ public static Vector<int> AsVectorInt32<T>(Vector<T> value) where T : struct
{
- return (Vector<Int32>)value;
+ return (Vector<int>)value;
}
/// <summary>
/// <returns>The reinterpreted vector.</returns>
[CLSCompliant(false)]
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<UInt64> AsVectorUInt64<T>(Vector<T> value) where T : struct
+ public static Vector<ulong> AsVectorUInt64<T>(Vector<T> value) where T : struct
{
- return (Vector<UInt64>)value;
+ return (Vector<ulong>)value;
}
/// <param name="value">The source vector</param>
/// <returns>The reinterpreted vector.</returns>
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<Int64> AsVectorInt64<T>(Vector<T> value) where T : struct
+ public static Vector<long> AsVectorInt64<T>(Vector<T> value) where T : struct
{
- return (Vector<Int64>)value;
+ return (Vector<long>)value;
}
/// <summary>
/// <param name="value">The source vector</param>
/// <returns>The reinterpreted vector.</returns>
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<Single> AsVectorSingle<T>(Vector<T> value) where T : struct
+ public static Vector<float> AsVectorSingle<T>(Vector<T> value) where T : struct
{
- return (Vector<Single>)value;
+ return (Vector<float>)value;
}
/// <summary>
/// <param name="value">The source vector</param>
/// <returns>The reinterpreted vector.</returns>
[MethodImplAttribute(MethodImplOptions.AggressiveInlining)]
- public static Vector<Double> AsVectorDouble<T>(Vector<T> value) where T : struct
+ public static Vector<double> AsVectorDouble<T>(Vector<T> value) where T : struct
{
- return (Vector<Double>)value;
+ return (Vector<double>)value;
}
#endregion Conversion Methods
}
, Inherited = false)]
public sealed class ObsoleteAttribute : Attribute
{
- private String _message;
+ private string _message;
private bool _error;
public ObsoleteAttribute()
_error = false;
}
- public ObsoleteAttribute(String message)
+ public ObsoleteAttribute(string message)
{
_message = message;
_error = false;
}
- public ObsoleteAttribute(String message, bool error)
+ public ObsoleteAttribute(string message, bool error)
{
_message = message;
_error = error;
}
- public String Message
+ public string Message
{
get { return _message; }
}
HResult = HResults.COR_E_OPERATIONCANCELED;
}
- public OperationCanceledException(String message)
+ public OperationCanceledException(string message)
: base(message)
{
HResult = HResults.COR_E_OPERATIONCANCELED;
}
- public OperationCanceledException(String message, Exception innerException)
+ public OperationCanceledException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_OPERATIONCANCELED;
CancellationToken = token;
}
- public OperationCanceledException(String message, CancellationToken token)
+ public OperationCanceledException(string message, CancellationToken token)
: this(message)
{
CancellationToken = token;
}
- public OperationCanceledException(String message, Exception innerException, CancellationToken token)
+ public OperationCanceledException(string message, Exception innerException, CancellationToken token)
: this(message, innerException)
{
CancellationToken = token;
HResult = HResults.COR_E_OUTOFMEMORY;
}
- public OutOfMemoryException(String message)
+ public OutOfMemoryException(string message)
: base(message)
{
HResult = HResults.COR_E_OUTOFMEMORY;
}
- public OutOfMemoryException(String message, Exception innerException)
+ public OutOfMemoryException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_OUTOFMEMORY;
HResult = HResults.COR_E_OVERFLOW;
}
- public OverflowException(String message)
+ public OverflowException(string message)
: base(message)
{
HResult = HResults.COR_E_OVERFLOW;
}
- public OverflowException(String message, Exception innerException)
+ public OverflowException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_OVERFLOW;
HResult = HResults.COR_E_PLATFORMNOTSUPPORTED;
}
- public PlatformNotSupportedException(String message)
+ public PlatformNotSupportedException(string message)
: base(message)
{
HResult = HResults.COR_E_PLATFORMNOTSUPPORTED;
}
- public PlatformNotSupportedException(String message, Exception inner)
+ public PlatformNotSupportedException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_PLATFORMNOTSUPPORTED;
/*=====================================Next=====================================
- **Returns: An int [0..Int32.MaxValue)
+ **Returns: An int [0..int.MaxValue)
**Arguments: None
**Exceptions: None.
==============================================================================*/
{
// The distribution of double value returned by Sample
// is not distributed well enough for a large range.
- // If we use Sample for a range [Int32.MinValue..Int32.MaxValue)
+ // If we use Sample for a range [int.MinValue..int.MaxValue)
// We will end up getting even numbers only.
int result = InternalSample();
HResult = HResults.COR_E_RANK;
}
- public RankException(String message)
+ public RankException(string message)
: base(message)
{
HResult = HResults.COR_E_RANK;
}
- public RankException(String message, Exception innerException)
+ public RankException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_RANK;
Returns true if the assembly was loaded from the global assembly cache.
*/
public virtual bool GlobalAssemblyCache { get { throw NotImplemented.ByDesign; } }
- public virtual Int64 HostContext { get { throw NotImplemented.ByDesign; } }
+ public virtual long HostContext { get { throw NotImplemented.ByDesign; } }
public override bool Equals(object o) => base.Equals(o);
public override int GetHashCode() => base.GetHashCode();
return m_label;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj is Label)
return Equals((Label)obj);
private static volatile string[] g_nameCache;
- public String Name
+ public string Name
{
get
{
string[] nameCache = g_nameCache;
if (nameCache == null)
{
- nameCache = new String[0x11f];
+ nameCache = new string[0x11f];
g_nameCache = nameCache;
}
}
}
- String name = Volatile.Read(ref nameCache[idx]);
+ string name = Volatile.Read(ref nameCache[idx]);
if (name != null)
return name;
}
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
if (obj is OpCode)
return Equals((OpCode)obj);
return Value;
}
- public override String ToString()
+ public override string ToString()
{
return Name;
}
internal static readonly FastResourceComparer Default = new FastResourceComparer();
// Implements IHashCodeProvider too, due to Hashtable requirements.
- public int GetHashCode(Object key)
+ public int GetHashCode(object key)
{
string s = (string)key;
return FastResourceComparer.HashFunction(s);
}
// Compares Strings quickly in a case-sensitive way
- public int Compare(Object a, Object b)
+ public int Compare(object a, object b)
{
if (a == b) return 0;
string sa = (string)a;
return string.Equals(a, b);
}
- public new bool Equals(Object a, Object b)
+ public new bool Equals(object a, object b)
{
if (a == b) return true;
string sa = (string)a;
[System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
public class MissingSatelliteAssemblyException : SystemException
{
- private String _cultureName;
+ private string _cultureName;
public MissingSatelliteAssemblyException()
: base(SR.MissingSatelliteAssembly_Default)
HResult = System.HResults.COR_E_MISSINGSATELLITEASSEMBLY;
}
- public MissingSatelliteAssemblyException(string message, String cultureName)
+ public MissingSatelliteAssemblyException(string message, string cultureName)
: base(message)
{
HResult = System.HResults.COR_E_MISSINGSATELLITEASSEMBLY;
{
}
- public String CultureName
+ public string CultureName
{
get { return _cultureName; }
}
// for arbitrarily long times, since the object is usually a string
// literal that will live for the lifetime of the appdomain. The
// value is a ResourceLocator instance, which might cache the object.
- private Dictionary<String, ResourceLocator> _resCache;
+ private Dictionary<string, ResourceLocator> _resCache;
// For our special load-on-demand reader, cache the cast. The
// want to fill this out if we can avoid it. The problem is resource
// fallback will somewhat regularly cause us to look up resources that
// don't exist.
- private Dictionary<String, ResourceLocator> _caseInsensitiveTable;
+ private Dictionary<string, ResourceLocator> _caseInsensitiveTable;
// If we're not using our custom reader, then enumerate through all
// the resources once, adding them into the table.
private bool _haveReadFromReader;
- internal RuntimeResourceSet(String fileName) : base(false)
+ internal RuntimeResourceSet(string fileName) : base(false)
{
- _resCache = new Dictionary<String, ResourceLocator>(FastResourceComparer.Default);
+ _resCache = new Dictionary<string, ResourceLocator>(FastResourceComparer.Default);
Stream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.Read);
_defaultReader = new ResourceReader(stream, _resCache);
Reader = _defaultReader;
internal RuntimeResourceSet(Stream stream) : base(false)
{
- _resCache = new Dictionary<String, ResourceLocator>(FastResourceComparer.Default);
+ _resCache = new Dictionary<string, ResourceLocator>(FastResourceComparer.Default);
_defaultReader = new ResourceReader(stream, _resCache);
Reader = _defaultReader;
}
}
- public override String GetString(String key)
+ public override string GetString(string key)
{
- Object o = GetObject(key, false, true);
- return (String)o;
+ object o = GetObject(key, false, true);
+ return (string)o;
}
- public override String GetString(String key, bool ignoreCase)
+ public override string GetString(string key, bool ignoreCase)
{
- Object o = GetObject(key, ignoreCase, true);
- return (String)o;
+ object o = GetObject(key, ignoreCase, true);
+ return (string)o;
}
- public override Object GetObject(String key)
+ public override object GetObject(string key)
{
return GetObject(key, false, false);
}
- public override Object GetObject(String key, bool ignoreCase)
+ public override object GetObject(string key, bool ignoreCase)
{
return GetObject(key, ignoreCase, false);
}
- private Object GetObject(String key, bool ignoreCase, bool isString)
+ private object GetObject(string key, bool ignoreCase, bool isString)
{
if (key == null)
throw new ArgumentNullException(nameof(key));
if (Reader == null || _resCache == null)
throw new ObjectDisposedException(null, SR.ObjectDisposed_ResourceSet);
- Object value = null;
+ object value = null;
ResourceLocator resLocation;
lock (Reader)
// If necessary, init our case insensitive hash table.
if (ignoreCase && _caseInsensitiveTable == null)
{
- _caseInsensitiveTable = new Dictionary<String, ResourceLocator>(StringComparer.OrdinalIgnoreCase);
+ _caseInsensitiveTable = new Dictionary<string, ResourceLocator>(StringComparer.OrdinalIgnoreCase);
}
if (_defaultReader == null)
while (en.MoveNext())
{
DictionaryEntry entry = en.Entry;
- String readKey = (String)entry.Key;
+ string readKey = (string)entry.Key;
ResourceLocator resLoc = new ResourceLocator(-1, entry.Value);
_resCache.Add(readKey, resLoc);
if (ignoreCase)
while (en.MoveNext())
{
// Note: Always ask for the resource key before the data position.
- String currentKey = (String)en.Key;
+ string currentKey = (string)en.Key;
int dataPos = en.DataPosition;
ResourceLocator resLoc = new ResourceLocator(dataPos, null);
_caseInsensitiveTable.Add(currentKey, resLoc);
}
_haveReadFromReader = true;
}
- Object obj = null;
+ object obj = null;
bool found = false;
bool keyInWrongCase = false;
if (_defaultReader != null)
// The last parameter indicates whether the lookup required a
// case-insensitive lookup to succeed, indicating we shouldn't add
// the ResourceLocation to our case-sensitive cache.
- private Object ResolveResourceLocator(ResourceLocator resLocation, String key, Dictionary<String, ResourceLocator> copyOfCache, bool keyInWrongCase)
+ private object ResolveResourceLocator(ResourceLocator resLocation, string key, Dictionary<string, ResourceLocator> copyOfCache, bool keyInWrongCase)
{
// We need to explicitly resolve loosely linked manifest
// resources, and we need to resolve ResourceLocators with null objects.
- Object value = resLocation.Value;
+ object value = resLocation.Value;
if (value == null)
{
ResourceTypeCode typeCode;
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false)]
public sealed class SatelliteContractVersionAttribute : Attribute
{
- public SatelliteContractVersionAttribute(String version)
+ public SatelliteContractVersionAttribute(string version)
{
if (version == null)
throw new ArgumentNullException(nameof(version));
Version = version;
}
- public String Version { get; }
+ public string Version { get; }
}
}
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
public abstract class CustomConstantAttribute : Attribute
{
- public abstract Object Value { get; }
+ public abstract object Value { get; }
}
}
_date = new DateTime(ticks);
}
- public override Object Value => _date;
+ public override object Value => _date;
}
}
[AttributeUsage(AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
public sealed class DecimalConstantAttribute : Attribute
{
- private Decimal _dec;
+ private decimal _dec;
[CLSCompliant(false)]
public DecimalConstantAttribute(
uint low
)
{
- _dec = new Decimal((int)low, (int)mid, (int)hi, (sign != 0), scale);
+ _dec = new decimal((int)low, (int)mid, (int)hi, (sign != 0), scale);
}
public DecimalConstantAttribute(
int low
)
{
- _dec = new Decimal(low, mid, hi, (sign != 0), scale);
+ _dec = new decimal(low, mid, hi, (sign != 0), scale);
}
- public Decimal Value => _dec;
+ public decimal Value => _dec;
}
}
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
public sealed class DependencyAttribute : Attribute
{
- public DependencyAttribute(String dependentAssemblyArgument, LoadHint loadHintArgument)
+ public DependencyAttribute(string dependentAssemblyArgument, LoadHint loadHintArgument)
{
DependentAssembly = dependentAssemblyArgument;
LoadHint = loadHintArgument;
}
- public String DependentAssembly { get; }
+ public string DependentAssembly { get; }
public LoadHint LoadHint { get; }
}
}
\ No newline at end of file
[AttributeUsage(AttributeTargets.Property, Inherited = true)]
public sealed class IndexerNameAttribute : Attribute
{
- public IndexerNameAttribute(String indexerName)
+ public IndexerNameAttribute(string indexerName)
{
}
}
{
}
- public ReferenceAssemblyAttribute(String description)
+ public ReferenceAssemblyAttribute(string description)
{
Description = description;
}
- public String Description { get; }
+ public string Description { get; }
}
}
HResult = HResults.COR_E_MARSHALDIRECTIVE;
}
- public MarshalDirectiveException(String message)
+ public MarshalDirectiveException(string message)
: base(message)
{
HResult = HResults.COR_E_MARSHALDIRECTIVE;
}
- public MarshalDirectiveException(String message, Exception inner)
+ public MarshalDirectiveException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_MARSHALDIRECTIVE;
/// Thrown when <typeparamref name="T"/> contains pointers.
/// </exception>
/// <exception cref="System.OverflowException">
- /// Thrown if the Length property of the new Span would exceed Int32.MaxValue.
+ /// Thrown if the Length property of the new Span would exceed int.MaxValue.
/// </exception>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static Span<byte> AsBytes<T>(Span<T> span)
/// Thrown when <typeparamref name="T"/> contains pointers.
/// </exception>
/// <exception cref="System.OverflowException">
- /// Thrown if the Length property of the new Span would exceed Int32.MaxValue.
+ /// Thrown if the Length property of the new Span would exceed int.MaxValue.
/// </exception>
[MethodImpl(MethodImplOptions.AggressiveInlining)]
public static ReadOnlySpan<byte> AsBytes<T>(ReadOnlySpan<T> span)
{
// Steal UIntPtr.MaxValue as our uninitialized value.
private static readonly UIntPtr Uninitialized = (UIntPtr.Size == 4) ?
- ((UIntPtr)UInt32.MaxValue) : ((UIntPtr)UInt64.MaxValue);
+ ((UIntPtr)uint.MaxValue) : ((UIntPtr)ulong.MaxValue);
private UIntPtr _numBytes;
[CLSCompliant(false)]
public void Initialize(ulong numBytes)
{
- if (IntPtr.Size == 4 && numBytes > UInt32.MaxValue)
+ if (IntPtr.Size == 4 && numBytes > uint.MaxValue)
throw new ArgumentOutOfRangeException(nameof(numBytes), SR.ArgumentOutOfRange_AddressSpace);
if (numBytes >= (ulong)Uninitialized)
[CLSCompliant(false)]
public void Initialize(uint numElements, uint sizeOfEachElement)
{
- if (IntPtr.Size == 4 && numElements * sizeOfEachElement > UInt32.MaxValue)
+ if (IntPtr.Size == 4 && numElements * sizeOfEachElement > uint.MaxValue)
throw new ArgumentOutOfRangeException("numBytes", SR.ArgumentOutOfRange_AddressSpace);
if (numElements * sizeOfEachElement >= (ulong)Uninitialized)
[System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
public class SerializationException : SystemException
{
- private static String s_nullMessage = SR.SerializationException;
+ private static string s_nullMessage = SR.SerializationException;
// Creates a new SerializationException with its message
// string set to a default message.
HResult = HResults.COR_E_SERIALIZATION;
}
- public SerializationException(String message)
+ public SerializationException(string message)
: base(message)
{
HResult = HResults.COR_E_SERIALIZATION;
}
- public SerializationException(String message, Exception innerException)
+ public SerializationException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_SERIALIZATION;
[AttributeUsageAttribute(AttributeTargets.Assembly, AllowMultiple = false, Inherited = false)]
public sealed class TargetFrameworkAttribute : Attribute
{
- private String _frameworkName; // A target framework moniker
- private String _frameworkDisplayName;
+ private string _frameworkName; // A target framework moniker
+ private string _frameworkDisplayName;
// The frameworkName parameter is intended to be the string form of a FrameworkName instance.
- public TargetFrameworkAttribute(String frameworkName)
+ public TargetFrameworkAttribute(string frameworkName)
{
if (frameworkName == null)
throw new ArgumentNullException(nameof(frameworkName));
// The target framework moniker that this assembly was compiled against.
// Use the FrameworkName class to interpret target framework monikers.
- public String FrameworkName
+ public string FrameworkName
{
get { return _frameworkName; }
}
- public String FrameworkDisplayName
+ public string FrameworkDisplayName
{
get { return _frameworkDisplayName; }
set { _frameworkDisplayName = value; }
[Serializable]
[CLSCompliant(false)] [StructLayout(LayoutKind.Sequential)]
[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public struct SByte : IComparable, IConvertible, IFormattable, IComparable<SByte>, IEquatable<SByte>, ISpanFormattable
+ public struct SByte : IComparable, IConvertible, IFormattable, IComparable<sbyte>, IEquatable<sbyte>, ISpanFormattable
{
private sbyte m_value; // Do not rename (binary serialization)
// null is considered to be less than any instance.
// If object is not of type SByte, this method throws an ArgumentException.
//
- public int CompareTo(Object obj)
+ public int CompareTo(object obj)
{
if (obj == null)
{
return 1;
}
- if (!(obj is SByte))
+ if (!(obj is sbyte))
{
throw new ArgumentException(SR.Arg_MustBeSByte);
}
- return m_value - ((SByte)obj).m_value;
+ return m_value - ((sbyte)obj).m_value;
}
- public int CompareTo(SByte value)
+ public int CompareTo(sbyte value)
{
return m_value - value;
}
// Determines whether two Byte objects are equal.
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
- if (!(obj is SByte))
+ if (!(obj is sbyte))
{
return false;
}
- return m_value == ((SByte)obj).m_value;
+ return m_value == ((sbyte)obj).m_value;
}
[NonVersionable]
- public bool Equals(SByte obj)
+ public bool Equals(sbyte obj)
{
return m_value == obj;
}
// Provides a string representation of a byte.
- public override String ToString()
+ public override string ToString()
{
return Number.FormatInt32(m_value, null, null);
}
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
return Number.FormatInt32(m_value, null, provider);
}
- public String ToString(String format)
+ public string ToString(string format)
{
return ToString(format, null);
}
- public String ToString(String format, IFormatProvider provider)
+ public string ToString(string format, IFormatProvider provider)
{
if (m_value < 0 && format != null && format.Length > 0 && (format[0] == 'X' || format[0] == 'x'))
{
}
[CLSCompliant(false)]
- public static sbyte Parse(String s)
+ public static sbyte Parse(string s)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
}
[CLSCompliant(false)]
- public static sbyte Parse(String s, NumberStyles style)
+ public static sbyte Parse(string s, NumberStyles style)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
}
[CLSCompliant(false)]
- public static sbyte Parse(String s, IFormatProvider provider)
+ public static sbyte Parse(string s, IFormatProvider provider)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
// NumberFormatInfo is assumed.
//
[CLSCompliant(false)]
- public static sbyte Parse(String s, NumberStyles style, IFormatProvider provider)
+ public static sbyte Parse(string s, NumberStyles style, IFormatProvider provider)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Parse(s, style, NumberFormatInfo.GetInstance(provider));
}
- private static sbyte Parse(String s, NumberStyles style, NumberFormatInfo info)
+ private static sbyte Parse(string s, NumberStyles style, NumberFormatInfo info)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Parse((ReadOnlySpan<char>)s, style, info);
if ((style & NumberStyles.AllowHexSpecifier) != 0)
{ // We are parsing a hexadecimal number
- if ((i < 0) || i > Byte.MaxValue)
+ if ((i < 0) || i > byte.MaxValue)
{
throw new OverflowException(SR.Overflow_SByte);
}
}
[CLSCompliant(false)]
- public static bool TryParse(String s, out SByte result)
+ public static bool TryParse(string s, out sbyte result)
{
if (s == null)
{
}
[CLSCompliant(false)]
- public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out SByte result)
+ public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out sbyte result)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
}
- private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out SByte result)
+ private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out sbyte result)
{
result = 0;
int i;
if ((style & NumberStyles.AllowHexSpecifier) != 0)
{ // We are parsing a hexadecimal number
- if ((i < 0) || i > Byte.MaxValue)
+ if ((i < 0) || i > byte.MaxValue)
{
return false;
}
return Convert.ToDouble(m_value);
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
return Convert.ToDecimal(m_value);
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "SByte", "DateTime"));
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
{
throw new ArgumentOutOfRangeException(nameof(index), SR.ArgumentOutOfRange_IndexString);
}
- Debug.Assert(index <= Int32.MaxValue / sizeof(char));
+ Debug.Assert(index <= int.MaxValue / sizeof(char));
EnsureNotDisposed();
EnsureNotReadOnly();
[Serializable]
[StructLayout(LayoutKind.Sequential)]
[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public struct Single : IComparable, IConvertible, IFormattable, IComparable<Single>, IEquatable<Single>, ISpanFormattable
+ public struct Single : IComparable, IConvertible, IFormattable, IComparable<float>, IEquatable<float>, ISpanFormattable
{
private float m_value; // Do not rename (binary serialization)
// null is considered to be less than any instance.
// If object is not of type Single, this method throws an ArgumentException.
//
- public int CompareTo(Object value)
+ public int CompareTo(object value)
{
if (value == null)
{
return 1;
}
- if (value is Single)
+ if (value is float)
{
float f = (float)value;
if (m_value < f) return -1;
}
- public int CompareTo(Single value)
+ public int CompareTo(float value)
{
if (m_value < value) return -1;
if (m_value > value) return 1;
}
[NonVersionable]
- public static bool operator ==(Single left, Single right)
+ public static bool operator ==(float left, float right)
{
return left == right;
}
[NonVersionable]
- public static bool operator !=(Single left, Single right)
+ public static bool operator !=(float left, float right)
{
return left != right;
}
[NonVersionable]
- public static bool operator <(Single left, Single right)
+ public static bool operator <(float left, float right)
{
return left < right;
}
[NonVersionable]
- public static bool operator >(Single left, Single right)
+ public static bool operator >(float left, float right)
{
return left > right;
}
[NonVersionable]
- public static bool operator <=(Single left, Single right)
+ public static bool operator <=(float left, float right)
{
return left <= right;
}
[NonVersionable]
- public static bool operator >=(Single left, Single right)
+ public static bool operator >=(float left, float right)
{
return left >= right;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
- if (!(obj is Single))
+ if (!(obj is float))
{
return false;
}
- float temp = ((Single)obj).m_value;
+ float temp = ((float)obj).m_value;
if (temp == m_value)
{
return true;
return IsNaN(temp) && IsNaN(m_value);
}
- public bool Equals(Single obj)
+ public bool Equals(float obj)
{
if (obj == m_value)
{
return bits;
}
- public override String ToString()
+ public override string ToString()
{
return Number.FormatSingle(m_value, null, NumberFormatInfo.CurrentInfo);
}
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
return Number.FormatSingle(m_value, null, NumberFormatInfo.GetInstance(provider));
}
- public String ToString(String format)
+ public string ToString(string format)
{
return Number.FormatSingle(m_value, format, NumberFormatInfo.CurrentInfo);
}
- public String ToString(String format, IFormatProvider provider)
+ public string ToString(string format, IFormatProvider provider)
{
return Number.FormatSingle(m_value, format, NumberFormatInfo.GetInstance(provider));
}
// PositiveInfinity or NegativeInfinity for a number that is too
// large or too small.
//
- public static float Parse(String s)
+ public static float Parse(string s)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseSingle(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo);
}
- public static float Parse(String s, NumberStyles style)
+ public static float Parse(string s, NumberStyles style)
{
NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseSingle(s, style, NumberFormatInfo.CurrentInfo);
}
- public static float Parse(String s, IFormatProvider provider)
+ public static float Parse(string s, IFormatProvider provider)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseSingle(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.GetInstance(provider));
}
- public static float Parse(String s, NumberStyles style, IFormatProvider provider)
+ public static float Parse(string s, NumberStyles style, IFormatProvider provider)
{
NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseSingle(s, style, NumberFormatInfo.GetInstance(provider));
}
- public static Boolean TryParse(String s, out Single result)
+ public static bool TryParse(string s, out float result)
{
if (s == null)
{
return TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.CurrentInfo, out result);
}
- public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out Single result)
+ public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out float result)
{
NumberFormatInfo.ValidateParseStyleFloatingPoint(style);
return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
}
- private static Boolean TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out Single result)
+ private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out float result)
{
bool success = Number.TryParseSingle(s, style, info, out result);
if (!success)
return Convert.ToDouble(m_value);
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
return Convert.ToDecimal(m_value);
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "Single", "DateTime"));
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
HResult = HResults.COR_E_STACKOVERFLOW;
}
- public StackOverflowException(String message)
+ public StackOverflowException(string message)
: base(message)
{
HResult = HResults.COR_E_STACKOVERFLOW;
}
- public StackOverflowException(String message, Exception innerException)
+ public StackOverflowException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_STACKOVERFLOW;
return SplitInternal(separator ?? string.Empty, null, int.MaxValue, options);
}
- public string[] Split(string separator, Int32 count, StringSplitOptions options = StringSplitOptions.None)
+ public string[] Split(string separator, int count, StringSplitOptions options = StringSplitOptions.None)
{
return SplitInternal(separator ?? string.Empty, null, count, options);
}
return SplitInternal(null, separator, int.MaxValue, options);
}
- public string[] Split(string[] separator, Int32 count, StringSplitOptions options)
+ public string[] Split(string[] separator, int count, StringSplitOptions options)
{
return SplitInternal(null, separator, count, options);
}
}
// Trims the whitespace from both ends of the string. Whitespace is defined by
- // Char.IsWhiteSpace.
+ // char.IsWhiteSpace.
//
public string Trim() => TrimWhiteSpaceHelper(TrimType.Both);
namespace System
{
// The String class represents a static string of characters. Many of
- // the String methods perform some type of transformation on the current
- // instance and return the result as a new String. As with arrays, character
+ // the string methods perform some type of transformation on the current
+ // instance and return the result as a new string. As with arrays, character
// positions (indices) are zero-based.
[Serializable]
[System.Runtime.CompilerServices.TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public sealed partial class String : IComparable, IEnumerable, IConvertible, IEnumerable<char>, IComparable<String>, IEquatable<String>, ICloneable
+ public sealed partial class String : IComparable, IEnumerable, IConvertible, IEnumerable<char>, IComparable<string>, IEquatable<string>, ICloneable
{
// String constructors
// These are special. The implementation methods for these have a different signature from the
for (int i = 0; i < value.Length; i++)
{
- if (!Char.IsWhiteSpace(value[i])) return false;
+ if (!char.IsWhiteSpace(value[i])) return false;
}
return true;
return Convert.ToDouble(this, provider);
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
return Convert.ToDecimal(this, provider);
}
return Convert.ToDateTime(this, provider);
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
if (x == null) return -1;
if (y == null) return 1;
- String sa = x as String;
+ string sa = x as string;
if (sa != null)
{
- String sb = y as String;
+ string sb = y as string;
if (sb != null)
{
return Compare(sa, sb);
throw new ArgumentException(SR.Argument_ImplementIComparable);
}
- public new bool Equals(Object x, Object y)
+ public new bool Equals(object x, object y)
{
if (x == y) return true;
if (x == null || y == null) return false;
- String sa = x as String;
+ string sa = x as string;
if (sa != null)
{
- String sb = y as String;
+ string sb = y as string;
if (sb != null)
{
return Equals(sa, sb);
return obj.GetHashCode();
}
- public abstract int Compare(String x, String y);
- public abstract bool Equals(String x, String y);
+ public abstract int Compare(string x, string y);
+ public abstract bool Equals(string x, string y);
public abstract int GetHashCode(string obj);
}
HResult = HResults.COR_E_SYSTEM;
}
- public SystemException(String message)
+ public SystemException(string message)
: base(message)
{
HResult = HResults.COR_E_SYSTEM;
}
- public SystemException(String message, Exception innerException)
+ public SystemException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_SYSTEM;
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
// parent method is safe
- public override unsafe int GetByteCount(String chars)
+ public override unsafe int GetByteCount(string chars)
{
// Validate input
if (chars==null)
// So if you fix this, fix the others. Currently those include:
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
- public override unsafe int GetBytes(String chars, int charIndex, int charCount,
+ public override unsafe int GetBytes(string chars, int charIndex, int charCount,
byte[] bytes, int byteIndex)
{
if (chars == null || bytes == null)
if (encoder != null)
{
charLeftOver = encoder._charLeftOver;
- Debug.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver),
+ Debug.Assert(charLeftOver == 0 || char.IsHighSurrogate(charLeftOver),
"[ASCIIEncoding.GetByteCount]leftover character should be high surrogate");
fallback = encoder.Fallback as EncoderReplacementFallback;
// We may have a left over character from last time, try and process it.
if (charLeftOver > 0)
{
- Debug.Assert(Char.IsHighSurrogate(charLeftOver), "[ASCIIEncoding.GetByteCount]leftover character should be high surrogate");
+ Debug.Assert(char.IsHighSurrogate(charLeftOver), "[ASCIIEncoding.GetByteCount]leftover character should be high surrogate");
Debug.Assert(encoder != null, "[ASCIIEncoding.GetByteCount]Expected encoder");
// Since left over char was a surrogate, it'll have to be fallen back.
fallbackBuffer.InternalInitialize(charStart, charEnd, encoder, true);
}
- Debug.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver),
+ Debug.Assert(charLeftOver == 0 || char.IsHighSurrogate(charLeftOver),
"[ASCIIEncoding.GetBytes]leftover character should be high surrogate");
// Verify that we have no fallbackbuffer, for ASCII its always empty, so just assert
}
}
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
InternalDecoderBestFitFallback that = value as InternalDecoderBestFitFallback;
if (that != null)
private InternalDecoderBestFitFallback _oFallback;
// Private object for locking instead of locking on a public type for SQL reliability work.
- private static Object s_InternalSyncObject;
- private static Object InternalSyncObject
+ private static object s_InternalSyncObject;
+ private static object InternalSyncObject
{
get
{
if (s_InternalSyncObject == null)
{
- Object o = new Object();
- Interlocked.CompareExchange<Object>(ref s_InternalSyncObject, o, null);
+ object o = new object();
+ Interlocked.CompareExchange<object>(ref s_InternalSyncObject, o, null);
}
return s_InternalSyncObject;
}
}
}
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
DecoderExceptionFallback that = value as DecoderExceptionFallback;
if (that != null)
HResult = HResults.COR_E_ARGUMENT;
}
- public DecoderFallbackException(String message)
+ public DecoderFallbackException(string message)
: base(message)
{
HResult = HResults.COR_E_ARGUMENT;
}
- public DecoderFallbackException(String message, Exception innerException)
+ public DecoderFallbackException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_ARGUMENT;
}
- public DecoderFallbackException(String message, byte[] bytesUnknown, int index)
+ public DecoderFallbackException(string message, byte[] bytesUnknown, int index)
: base(message)
{
_bytesUnknown = bytesUnknown;
while ((ch = GetNextChar()) != 0)
{
// Make sure no mixed up surrogates
- if (Char.IsSurrogate(ch))
+ if (char.IsSurrogate(ch))
{
- if (Char.IsHighSurrogate(ch))
+ if (char.IsHighSurrogate(ch))
{
// High Surrogate
if (bHighSurrogate)
while ((ch = GetNextChar()) != 0)
{
// Make sure no mixed up surrogates
- if (Char.IsSurrogate(ch))
+ if (char.IsSurrogate(ch))
{
- if (Char.IsHighSurrogate(ch))
+ if (char.IsHighSurrogate(ch))
{
// High Surrogate
if (bHighSurrogate)
public sealed class DecoderReplacementFallback : DecoderFallback
{
// Our variables
- private String _strDefault;
+ private string _strDefault;
// Construction. Default replacement fallback uses no best fit and ? replacement string
public DecoderReplacementFallback() : this("?")
{
}
- public DecoderReplacementFallback(String replacement)
+ public DecoderReplacementFallback(string replacement)
{
if (replacement == null)
throw new ArgumentNullException(nameof(replacement));
for (int i = 0; i < replacement.Length; i++)
{
// Found a surrogate?
- if (Char.IsSurrogate(replacement, i))
+ if (char.IsSurrogate(replacement, i))
{
// High or Low?
- if (Char.IsHighSurrogate(replacement, i))
+ if (char.IsHighSurrogate(replacement, i))
{
// if already had a high one, stop
if (bFoundHigh)
_strDefault = replacement;
}
- public String DefaultString
+ public string DefaultString
{
get
{
}
}
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
DecoderReplacementFallback that = value as DecoderReplacementFallback;
if (that != null)
public sealed class DecoderReplacementFallbackBuffer : DecoderFallbackBuffer
{
// Store our default string
- private String _strDefault;
+ private string _strDefault;
private int _fallbackCount = -1;
private int _fallbackIndex = -1;
}
}
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
InternalEncoderBestFitFallback that = value as InternalEncoderBestFitFallback;
if (that != null)
private int _iSize;
// Private object for locking instead of locking on a public type for SQL reliability work.
- private static Object s_InternalSyncObject;
- private static Object InternalSyncObject
+ private static object s_InternalSyncObject;
+ private static object InternalSyncObject
{
get
{
if (s_InternalSyncObject == null)
{
- Object o = new Object();
- Interlocked.CompareExchange<Object>(ref s_InternalSyncObject, o, null);
+ object o = new object();
+ Interlocked.CompareExchange<object>(ref s_InternalSyncObject, o, null);
}
return s_InternalSyncObject;
}
public override bool Fallback(char charUnknownHigh, char charUnknownLow, int index)
{
// Double check input surrogate pair
- if (!Char.IsHighSurrogate(charUnknownHigh))
+ if (!char.IsHighSurrogate(charUnknownHigh))
throw new ArgumentOutOfRangeException(nameof(charUnknownHigh),
SR.Format(SR.ArgumentOutOfRange_Range,
0xD800, 0xDBFF));
- if (!Char.IsLowSurrogate(charUnknownLow))
+ if (!char.IsLowSurrogate(charUnknownLow))
throw new ArgumentOutOfRangeException(nameof(charUnknownLow),
SR.Format(SR.ArgumentOutOfRange_Range,
0xDC00, 0xDFFF));
}
}
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
EncoderExceptionFallback that = value as EncoderExceptionFallback;
if (that != null)
public override bool Fallback(char charUnknownHigh, char charUnknownLow, int index)
{
- if (!Char.IsHighSurrogate(charUnknownHigh))
+ if (!char.IsHighSurrogate(charUnknownHigh))
{
throw new ArgumentOutOfRangeException(nameof(charUnknownHigh),
SR.Format(SR.ArgumentOutOfRange_Range, 0xD800, 0xDBFF));
}
- if (!Char.IsLowSurrogate(charUnknownLow))
+ if (!char.IsLowSurrogate(charUnknownLow))
{
throw new ArgumentOutOfRangeException(nameof(charUnknownLow),
SR.Format(SR.ArgumentOutOfRange_Range, 0xDC00, 0xDFFF));
}
- int iTemp = Char.ConvertToUtf32(charUnknownHigh, charUnknownLow);
+ int iTemp = char.ConvertToUtf32(charUnknownHigh, charUnknownLow);
// Fall back our char
throw new EncoderFallbackException(
HResult = HResults.COR_E_ARGUMENT;
}
- public EncoderFallbackException(String message)
+ public EncoderFallbackException(string message)
: base(message)
{
HResult = HResults.COR_E_ARGUMENT;
}
- public EncoderFallbackException(String message, Exception innerException)
+ public EncoderFallbackException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_ARGUMENT;
}
internal EncoderFallbackException(
- String message, char charUnknown, int index) : base(message)
+ string message, char charUnknown, int index) : base(message)
{
_charUnknown = charUnknown;
_index = index;
}
internal EncoderFallbackException(
- String message, char charUnknownHigh, char charUnknownLow, int index) : base(message)
+ string message, char charUnknownHigh, char charUnknownLow, int index) : base(message)
{
- if (!Char.IsHighSurrogate(charUnknownHigh))
+ if (!char.IsHighSurrogate(charUnknownHigh))
{
throw new ArgumentOutOfRangeException(nameof(charUnknownHigh),
SR.Format(SR.ArgumentOutOfRange_Range, 0xD800, 0xDBFF));
}
- if (!Char.IsLowSurrogate(charUnknownLow))
+ if (!char.IsLowSurrogate(charUnknownLow))
{
throw new ArgumentOutOfRangeException(nameof(CharUnknownLow),
SR.Format(SR.ArgumentOutOfRange_Range, 0xDC00, 0xDFFF));
int index = (int)(chars - charStart) - 1;
// See if it was a high surrogate
- if (Char.IsHighSurrogate(ch))
+ if (char.IsHighSurrogate(ch))
{
// See if there's a low surrogate to go with it
if (chars >= this.charEnd)
{
// Might have a low surrogate
char cNext = *chars;
- if (Char.IsLowSurrogate(cNext))
+ if (char.IsLowSurrogate(cNext))
{
// If already falling back then fail
if (bFallingBack && iRecursionCount++ > iMaxRecursion)
- ThrowLastCharRecursive(Char.ConvertToUtf32(ch, cNext));
+ ThrowLastCharRecursive(char.ConvertToUtf32(ch, cNext));
// Next is a surrogate, add it as surrogate pair, and increment chars
chars++;
public sealed class EncoderReplacementFallback : EncoderFallback
{
// Our variables
- private String _strDefault;
+ private string _strDefault;
// Construction. Default replacement fallback uses no best fit and ? replacement string
public EncoderReplacementFallback() : this("?")
{
}
- public EncoderReplacementFallback(String replacement)
+ public EncoderReplacementFallback(string replacement)
{
// Must not be null
if (replacement == null)
for (int i = 0; i < replacement.Length; i++)
{
// Found a surrogate?
- if (Char.IsSurrogate(replacement, i))
+ if (char.IsSurrogate(replacement, i))
{
// High or Low?
- if (Char.IsHighSurrogate(replacement, i))
+ if (char.IsHighSurrogate(replacement, i))
{
// if already had a high one, stop
if (bFoundHigh)
_strDefault = replacement;
}
- public String DefaultString
+ public string DefaultString
{
get
{
}
}
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
EncoderReplacementFallback that = value as EncoderReplacementFallback;
if (that != null)
public sealed class EncoderReplacementFallbackBuffer : EncoderFallbackBuffer
{
// Store our default string
- private String _strDefault;
+ private string _strDefault;
private int _fallbackCount = -1;
private int _fallbackIndex = -1;
// If we're recursive we may still have something in our buffer that makes this a surrogate
if (char.IsHighSurrogate(charUnknown) && _fallbackCount >= 0 &&
char.IsLowSurrogate(_strDefault[_fallbackIndex + 1]))
- ThrowLastCharRecursive(Char.ConvertToUtf32(charUnknown, _strDefault[_fallbackIndex + 1]));
+ ThrowLastCharRecursive(char.ConvertToUtf32(charUnknown, _strDefault[_fallbackIndex + 1]));
// Nope, just one character
ThrowLastCharRecursive(unchecked((int)charUnknown));
public override bool Fallback(char charUnknownHigh, char charUnknownLow, int index)
{
// Double check input surrogate pair
- if (!Char.IsHighSurrogate(charUnknownHigh))
+ if (!char.IsHighSurrogate(charUnknownHigh))
throw new ArgumentOutOfRangeException(nameof(charUnknownHigh),
SR.Format(SR.ArgumentOutOfRange_Range, 0xD800, 0xDBFF));
- if (!Char.IsLowSurrogate(charUnknownLow))
+ if (!char.IsLowSurrogate(charUnknownLow))
throw new ArgumentOutOfRangeException(nameof(charUnknownLow),
SR.Format(SR.ArgumentOutOfRange_Range, 0xDC00, 0xDFFF));
// If we had a buffer already we're being recursive, throw, it's probably at the suspect
// character in our array.
if (_fallbackCount >= 1)
- ThrowLastCharRecursive(Char.ConvertToUtf32(charUnknownHigh, charUnknownLow));
+ ThrowLastCharRecursive(char.ConvertToUtf32(charUnknownHigh, charUnknownLow));
// Go ahead and get our fallback
_fallbackCount = _strDefault.Length;
}
- public virtual Object Clone()
+ public virtual object Clone()
{
Encoding newEncoding = (Encoding)this.MemberwiseClone();
private static Encoding BigEndianUTF32 => UTF32Encoding.s_bigEndianDefault;
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
Encoding that = value as Encoding;
if (that != null)
_encoding = encoding;
}
- public Object GetRealObject(StreamingContext context)
+ public object GetRealObject(StreamingContext context)
{
throw new PlatformNotSupportedException();
}
_encoding = encoding;
}
- public Object GetRealObject(StreamingContext context)
+ public object GetRealObject(StreamingContext context)
{
throw new PlatformNotSupportedException();
}
return Encoding.GetEncoding(iCodePage);
}
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
EncodingInfo that = value as EncodingInfo;
if (that != null)
// So if you fix this, fix the others. Currently those include:
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
// parent method is safe
- public override unsafe int GetByteCount(String s)
+ public override unsafe int GetByteCount(string s)
{
// Validate input
if (s==null)
// All of our public Encodings that don't use EncodingNLS must have this (including EncodingNLS)
// So if you fix this, fix the others. Currently those include:
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
- public override unsafe int GetBytes(String s, int charIndex, int charCount,
+ public override unsafe int GetBytes(string s, int charIndex, int charCount,
byte[] bytes, int byteIndex)
{
if (s == null || bytes == null)
return null;
}
- private static Object s_InternalSyncObject = new Object();
+ private static object s_InternalSyncObject = new object();
private static volatile EncodingProvider[] s_providers;
}
}
if (encoder != null)
{
charLeftOver = encoder._charLeftOver;
- Debug.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver),
+ Debug.Assert(charLeftOver == 0 || char.IsHighSurrogate(charLeftOver),
"[Latin1Encoding.GetByteCount]leftover character should be high surrogate");
fallback = encoder.Fallback as EncoderReplacementFallback;
{
charLeftOver = encoder._charLeftOver;
fallback = encoder.Fallback as EncoderReplacementFallback;
- Debug.Assert(charLeftOver == 0 || Char.IsHighSurrogate(charLeftOver),
+ Debug.Assert(charLeftOver == 0 || char.IsHighSurrogate(charLeftOver),
"[Latin1Encoding.GetBytes]leftover character should be high surrogate");
// Verify that we have no fallbackbuffer, for ASCII its always empty, so just assert
int persistedCapacity = 0;
string persistedString = null;
- int persistedMaxCapacity = Int32.MaxValue;
+ int persistedMaxCapacity = int.MaxValue;
bool capacityPresent = false;
// Get the data
[CLSCompliant(false)]
public StringBuilder Insert(int index, ulong value) => Insert(index, value.ToString(), 1);
- public StringBuilder Insert(int index, Object value) => (value == null) ? this : Insert(index, value.ToString(), 1);
+ public StringBuilder Insert(int index, object value) => (value == null) ? this : Insert(index, value.ToString(), 1);
public StringBuilder Insert(int index, ReadOnlySpan<char> value)
{
return this;
}
- public StringBuilder AppendFormat(string format, Object arg0) => AppendFormatHelper(null, format, new ParamsArray(arg0));
+ public StringBuilder AppendFormat(string format, object arg0) => AppendFormatHelper(null, format, new ParamsArray(arg0));
- public StringBuilder AppendFormat(string format, Object arg0, Object arg1) => AppendFormatHelper(null, format, new ParamsArray(arg0, arg1));
+ public StringBuilder AppendFormat(string format, object arg0, object arg1) => AppendFormatHelper(null, format, new ParamsArray(arg0, arg1));
- public StringBuilder AppendFormat(string format, Object arg0, Object arg1, Object arg2) => AppendFormatHelper(null, format, new ParamsArray(arg0, arg1, arg2));
+ public StringBuilder AppendFormat(string format, object arg0, object arg1, object arg2) => AppendFormatHelper(null, format, new ParamsArray(arg0, arg1, arg2));
- public StringBuilder AppendFormat(string format, params Object[] args)
+ public StringBuilder AppendFormat(string format, params object[] args)
{
if (args == null)
{
return AppendFormatHelper(null, format, new ParamsArray(args));
}
- public StringBuilder AppendFormat(IFormatProvider provider, string format, Object arg0) => AppendFormatHelper(provider, format, new ParamsArray(arg0));
+ public StringBuilder AppendFormat(IFormatProvider provider, string format, object arg0) => AppendFormatHelper(provider, format, new ParamsArray(arg0));
- public StringBuilder AppendFormat(IFormatProvider provider, string format, Object arg0, Object arg1) => AppendFormatHelper(provider, format, new ParamsArray(arg0, arg1));
+ public StringBuilder AppendFormat(IFormatProvider provider, string format, object arg0, object arg1) => AppendFormatHelper(provider, format, new ParamsArray(arg0, arg1));
- public StringBuilder AppendFormat(IFormatProvider provider, string format, Object arg0, Object arg1, Object arg2) => AppendFormatHelper(provider, format, new ParamsArray(arg0, arg1, arg2));
+ public StringBuilder AppendFormat(IFormatProvider provider, string format, object arg0, object arg1, object arg2) => AppendFormatHelper(provider, format, new ParamsArray(arg0, arg1, arg2));
- public StringBuilder AppendFormat(IFormatProvider provider, string format, params Object[] args)
+ public StringBuilder AppendFormat(IFormatProvider provider, string format, params object[] args)
{
if (args == null)
{
//
// Start of parsing of optional formatting parameter.
//
- Object arg = args[index];
+ object arg = args[index];
string itemFormat = null;
ReadOnlySpan<char> itemFormatSpan = default; // used if itemFormat is null
// Is current character a colon? which indicates start of formatting parameter.
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
// parent method is safe
- public override unsafe int GetByteCount(String s)
+ public override unsafe int GetByteCount(string s)
{
// Validate input
if (s==null)
// So if you fix this, fix the others. Currently those include:
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
- public override unsafe int GetBytes(String s, int charIndex, int charCount,
+ public override unsafe int GetBytes(string s, int charIndex, int charCount,
byte[] bytes, int byteIndex)
{
if (s == null || bytes == null)
//
// In previous char, we encounter a high surrogate, so we are expecting a low surrogate here.
//
- if (Char.IsLowSurrogate(ch))
+ if (char.IsLowSurrogate(ch))
{
// They're all legal
highSurrogate = '\0';
}
// Do we have another high surrogate?
- if (Char.IsHighSurrogate(ch))
+ if (char.IsHighSurrogate(ch))
{
//
// We'll have a high surrogate to check next time.
}
// Check for illegal characters
- if (Char.IsLowSurrogate(ch))
+ if (char.IsLowSurrogate(ch))
{
// We have a leading low surrogate, do the fallback
charsForFallback = chars;
//
// In previous char, we encountered a high surrogate, so we are expecting a low surrogate here.
//
- if (Char.IsLowSurrogate(ch))
+ if (char.IsLowSurrogate(ch))
{
// Is it a legal one?
uint iTemp = GetSurrogate(highSurrogate, ch);
}
// Do we have another high surrogate?, if so remember it
- if (Char.IsHighSurrogate(ch))
+ if (char.IsHighSurrogate(ch))
{
//
// We'll have a high surrogate to check next time.
}
// Check for illegal characters (low surrogate)
- if (Char.IsLowSurrogate(ch))
+ if (char.IsLowSurrogate(ch))
{
// We have a leading low surrogate, do the fallback
charsForFallback = chars;
_emitUTF32ByteOrderMark ? (_bigEndian ? s_bigEndianPreamble : s_littleEndianPreamble) :
Array.Empty<byte>();
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
UTF32Encoding that = value as UTF32Encoding;
if (that != null)
this.decoderFallback = new DecoderUTF7Fallback();
}
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
UTF7Encoding that = value as UTF7Encoding;
if (that != null)
}
}
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
DecoderUTF7Fallback that = value as DecoderUTF7Fallback;
if (that != null)
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
// parent method is safe
- public override unsafe int GetByteCount(String chars)
+ public override unsafe int GetByteCount(string chars)
{
// Validate input
if (chars==null)
// So if you fix this, fix the others. Currently those include:
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
- public override unsafe int GetBytes(String s, int charIndex, int charCount,
+ public override unsafe int GetBytes(string s, int charIndex, int charCount,
byte[] bytes, int byteIndex)
{
if (s == null || bytes == null)
_emitUTF8Identifier ? s_preamble :
Array.Empty<byte>();
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
UTF8Encoding that = value as UTF8Encoding;
if (that != null)
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
// parent method is safe
- public override unsafe int GetByteCount(String s)
+ public override unsafe int GetByteCount(string s)
{
// Validate input
if (s==null)
// So if you fix this, fix the others. Currently those include:
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
- public override unsafe int GetBytes(String s, int charIndex, int charCount,
+ public override unsafe int GetBytes(string s, int charIndex, int charCount,
byte[] bytes, int byteIndex)
{
if (s == null || bytes == null)
else
return new byte[2] { 0xff, 0xfe };
}
- return Array.Empty<Byte>();
+ return Array.Empty<byte>();
}
public override ReadOnlySpan<byte> Preamble =>
}
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
UnicodeEncoding that = value as UnicodeEncoding;
if (that != null)
HResult = HResults.COR_E_ABANDONEDMUTEX;
}
- public AbandonedMutexException(String message)
+ public AbandonedMutexException(string message)
: base(message)
{
HResult = HResults.COR_E_ABANDONEDMUTEX;
}
- public AbandonedMutexException(String message, Exception inner)
+ public AbandonedMutexException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_ABANDONEDMUTEX;
SetupException(location, handle);
}
- public AbandonedMutexException(String message, int location, WaitHandle handle)
+ public AbandonedMutexException(string message, int location, WaitHandle handle)
: base(message)
{
HResult = HResults.COR_E_ABANDONEDMUTEX;
SetupException(location, handle);
}
- public AbandonedMutexException(String message, Exception inner, int location, WaitHandle handle)
+ public AbandonedMutexException(string message, Exception inner, int location, WaitHandle handle)
: base(message, inner)
{
HResult = HResults.COR_E_ABANDONEDMUTEX;
namespace System.Threading
{
- public delegate void ContextCallback(Object state);
+ public delegate void ContextCallback(object state);
public sealed class ExecutionContext : IDisposable, ISerializable
{
internal bool IsDefault => m_isDefault;
- public static void Run(ExecutionContext executionContext, ContextCallback callback, Object state)
+ public static void Run(ExecutionContext executionContext, ContextCallback callback, object state)
{
// Note: ExecutionContext.Run is an extremely hot function and used by every await, ThreadPool execution, etc.
if (executionContext == null)
RunInternal(executionContext, callback, state);
}
- internal static void RunInternal(ExecutionContext executionContext, ContextCallback callback, Object state)
+ internal static void RunInternal(ExecutionContext executionContext, ContextCallback callback, object state)
{
// Note: ExecutionContext.RunInternal is an extremely hot function and used by every await, ThreadPool execution, etc.
// Note: Manual enregistering may be addressed by "Exception Handling Write Through Optimization"
public TimeoutTracker(TimeSpan timeout)
{
long ltm = (long)timeout.TotalMilliseconds;
- if (ltm < -1 || ltm > (long)Int32.MaxValue)
+ if (ltm < -1 || ltm > (long)int.MaxValue)
throw new ArgumentOutOfRangeException(nameof(timeout));
_total = (int)ltm;
if (_total != -1 && _total != 0)
public sealed partial class Semaphore : WaitHandle
{
// creates a nameless semaphore object
- // Win32 only takes maximum count of Int32.MaxValue
+ // Win32 only takes maximum count of int.MaxValue
public Semaphore(int initialCount, int maximumCount) : this(initialCount, maximumCount, null) { }
public Semaphore(int initialCount, int maximumCount, string name) :
{
}
- public SemaphoreFullException(String message) : base(message)
+ public SemaphoreFullException(string message) : base(message)
{
}
- public SemaphoreFullException(String message, Exception innerException) : base(message, innerException)
+ public SemaphoreFullException(string message, Exception innerException) : base(message, innerException)
{
}
namespace System.Threading
{
- public delegate void SendOrPostCallback(Object state);
+ public delegate void SendOrPostCallback(object state);
}
/// <exception cref="ArgumentNullException">The <paramref name="condition"/> argument is null.</exception>
/// <exception cref="T:System.ArgumentOutOfRangeException"><paramref name="timeout"/> is a negative number
/// other than -1 milliseconds, which represents an infinite time-out -or- timeout is greater than
- /// <see cref="System.Int32.MaxValue"/>.</exception>
+ /// <see cref="System.int.MaxValue"/>.</exception>
public static bool SpinUntil(Func<bool> condition, TimeSpan timeout)
{
// Validate the timeout
HResult = HResults.COR_E_SYNCHRONIZATIONLOCK;
}
- public SynchronizationLockException(String message)
+ public SynchronizationLockException(string message)
: base(message)
{
HResult = HResults.COR_E_SYNCHRONIZATIONLOCK;
}
- public SynchronizationLockException(String message, Exception innerException)
+ public SynchronizationLockException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_SYNCHRONIZATIONLOCK;
/// <summary>Default MaxItemsPerTask to use for processing if none is specified.</summary>
private const int DEFAULT_MAXITEMSPERTASK = UNLIMITED_PROCESSING;
/// <summary>Default MaxConcurrencyLevel is the processor count if not otherwise specified.</summary>
- private static Int32 DefaultMaxConcurrencyLevel { get { return Environment.ProcessorCount; } }
+ private static int DefaultMaxConcurrencyLevel { get { return Environment.ProcessorCount; } }
/// <summary>Gets the sync obj used to protect all state on this instance.</summary>
private object ValueLock { get { return m_threadProcessingMode; } }
// Treat UNLIMITED_PROCESSING/-1 for both MCL and MIPT as the biggest possible value so that we don't
// have to special case UNLIMITED_PROCESSING later on in processing.
- if (m_maxConcurrencyLevel == UNLIMITED_PROCESSING) m_maxConcurrencyLevel = Int32.MaxValue;
- if (m_maxItemsPerTask == UNLIMITED_PROCESSING) m_maxItemsPerTask = Int32.MaxValue;
+ if (m_maxConcurrencyLevel == UNLIMITED_PROCESSING) m_maxConcurrencyLevel = int.MaxValue;
+ if (m_maxItemsPerTask == UNLIMITED_PROCESSING) m_maxItemsPerTask = int.MaxValue;
// Create the concurrent/exclusive schedulers for this pair
m_exclusiveTaskScheduler = new ConcurrentExclusiveTaskScheduler(this, 1, ProcessingMode.ProcessingExclusiveTask);
HResult = HResults.COR_E_THREADINTERRUPTED;
}
- public ThreadInterruptedException(String message)
+ public ThreadInterruptedException(string message)
: base(message)
{
HResult = HResults.COR_E_THREADINTERRUPTED;
}
- public ThreadInterruptedException(String message, Exception innerException)
+ public ThreadInterruptedException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_THREADINTERRUPTED;
HResult = HResults.COR_E_THREADSTATE;
}
- public ThreadStateException(String message)
+ public ThreadStateException(string message)
: base(message)
{
HResult = HResults.COR_E_THREADSTATE;
}
- public ThreadStateException(String message, Exception innerException)
+ public ThreadStateException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_THREADSTATE;
HResult = HResults.COR_E_WAITHANDLECANNOTBEOPENED;
}
- public WaitHandleCannotBeOpenedException(String message) : base(message)
+ public WaitHandleCannotBeOpenedException(string message) : base(message)
{
HResult = HResults.COR_E_WAITHANDLECANNOTBEOPENED;
}
- public WaitHandleCannotBeOpenedException(String message, Exception innerException) : base(message, innerException)
+ public WaitHandleCannotBeOpenedException(string message, Exception innerException) : base(message, innerException)
{
HResult = HResults.COR_E_WAITHANDLECANNOTBEOPENED;
}
private const int MillisPerHour = MillisPerMinute * 60; // 3,600,000
private const int MillisPerDay = MillisPerHour * 24; // 86,400,000
- internal const long MaxSeconds = Int64.MaxValue / TicksPerSecond;
- internal const long MinSeconds = Int64.MinValue / TicksPerSecond;
+ internal const long MaxSeconds = long.MaxValue / TicksPerSecond;
+ internal const long MinSeconds = long.MinValue / TicksPerSecond;
- internal const long MaxMilliSeconds = Int64.MaxValue / TicksPerMillisecond;
- internal const long MinMilliSeconds = Int64.MinValue / TicksPerMillisecond;
+ internal const long MaxMilliSeconds = long.MaxValue / TicksPerMillisecond;
+ internal const long MinMilliSeconds = long.MinValue / TicksPerMillisecond;
internal const long TicksPerTenthSecond = TicksPerMillisecond * 100;
public static readonly TimeSpan Zero = new TimeSpan(0);
- public static readonly TimeSpan MaxValue = new TimeSpan(Int64.MaxValue);
- public static readonly TimeSpan MinValue = new TimeSpan(Int64.MinValue);
+ public static readonly TimeSpan MaxValue = new TimeSpan(long.MaxValue);
+ public static readonly TimeSpan MinValue = new TimeSpan(long.MinValue);
// internal so that DateTime doesn't have to call an extra get
// method for some arithmetic operations.
public TimeSpan(int days, int hours, int minutes, int seconds, int milliseconds)
{
- Int64 totalMilliSeconds = ((Int64)days * 3600 * 24 + (Int64)hours * 3600 + (Int64)minutes * 60 + seconds) * 1000 + milliseconds;
+ long totalMilliSeconds = ((long)days * 3600 * 24 + (long)hours * 3600 + (long)minutes * 60 + seconds) * 1000 + milliseconds;
if (totalMilliSeconds > MaxMilliSeconds || totalMilliSeconds < MinMilliSeconds)
throw new ArgumentOutOfRangeException(null, SR.Overflow_TimeSpanTooLong);
_ticks = (long)totalMilliSeconds * TicksPerMillisecond;
}
// Returns a value less than zero if this object
- public int CompareTo(Object value)
+ public int CompareTo(object value)
{
if (value == null) return 1;
if (!(value is TimeSpan))
return new TimeSpan(_ticks >= 0 ? _ticks : -_ticks);
}
- public override bool Equals(Object value)
+ public override bool Equals(object value)
{
if (value is TimeSpan)
{
private static TimeSpan Interval(double value, int scale)
{
- if (Double.IsNaN(value))
+ if (double.IsNaN(value))
throw new ArgumentException(SR.Arg_CannotBeNaN);
double tmp = value * scale;
double millis = tmp + (value >= 0 ? 0.5 : -0.5);
- if ((millis > Int64.MaxValue / TicksPerMillisecond) || (millis < Int64.MinValue / TicksPerMillisecond))
+ if ((millis > long.MaxValue / TicksPerMillisecond) || (millis < long.MinValue / TicksPerMillisecond))
throw new OverflowException(SR.Overflow_TimeSpanTooLong);
return new TimeSpan((long)millis * TicksPerMillisecond);
}
// See System.Globalization.TimeSpanParse and System.Globalization.TimeSpanFormat
#region ParseAndFormat
- private static void ValidateStyles(TimeSpanStyles style, String parameterName)
+ private static void ValidateStyles(TimeSpanStyles style, string parameterName)
{
if (style != TimeSpanStyles.None && style != TimeSpanStyles.AssumeNegative)
throw new ArgumentException(SR.Argument_InvalidTimeSpanStyles, parameterName);
}
- public static TimeSpan Parse(String s)
+ public static TimeSpan Parse(string s)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
/* Constructs a TimeSpan from a string. Leading and trailing white space characters are allowed. */
return TimeSpanParse.Parse(s, null);
}
- public static TimeSpan Parse(String input, IFormatProvider formatProvider)
+ public static TimeSpan Parse(string input, IFormatProvider formatProvider)
{
if (input == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
return TimeSpanParse.Parse(input, formatProvider);
{
return TimeSpanParse.Parse(input, formatProvider);
}
- public static TimeSpan ParseExact(String input, String format, IFormatProvider formatProvider)
+ public static TimeSpan ParseExact(string input, string format, IFormatProvider formatProvider)
{
if (input == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
if (format == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.format);
return TimeSpanParse.ParseExact(input, format, formatProvider, TimeSpanStyles.None);
}
- public static TimeSpan ParseExact(String input, String[] formats, IFormatProvider formatProvider)
+ public static TimeSpan ParseExact(string input, string[] formats, IFormatProvider formatProvider)
{
if (input == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
return TimeSpanParse.ParseExactMultiple(input, formats, formatProvider, TimeSpanStyles.None);
}
- public static TimeSpan ParseExact(String input, String format, IFormatProvider formatProvider, TimeSpanStyles styles)
+ public static TimeSpan ParseExact(string input, string format, IFormatProvider formatProvider, TimeSpanStyles styles)
{
ValidateStyles(styles, nameof(styles));
if (input == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
ValidateStyles(styles, nameof(styles));
return TimeSpanParse.ParseExact(input, format, formatProvider, styles);
}
- public static TimeSpan ParseExact(String input, String[] formats, IFormatProvider formatProvider, TimeSpanStyles styles)
+ public static TimeSpan ParseExact(string input, string[] formats, IFormatProvider formatProvider, TimeSpanStyles styles)
{
ValidateStyles(styles, nameof(styles));
if (input == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.input);
ValidateStyles(styles, nameof(styles));
return TimeSpanParse.ParseExactMultiple(input, formats, formatProvider, styles);
}
- public static Boolean TryParse(String s, out TimeSpan result)
+ public static bool TryParse(string s, out TimeSpan result)
{
if (s == null)
{
return TimeSpanParse.TryParse(s, null, out result);
}
- public static Boolean TryParse(String input, IFormatProvider formatProvider, out TimeSpan result)
+ public static bool TryParse(string input, IFormatProvider formatProvider, out TimeSpan result)
{
if (input == null)
{
{
return TimeSpanParse.TryParse(input, formatProvider, out result);
}
- public static Boolean TryParseExact(String input, String format, IFormatProvider formatProvider, out TimeSpan result)
+ public static bool TryParseExact(string input, string format, IFormatProvider formatProvider, out TimeSpan result)
{
if (input == null || format == null)
{
{
return TimeSpanParse.TryParseExact(input, format, formatProvider, TimeSpanStyles.None, out result);
}
- public static Boolean TryParseExact(String input, String[] formats, IFormatProvider formatProvider, out TimeSpan result)
+ public static bool TryParseExact(string input, string[] formats, IFormatProvider formatProvider, out TimeSpan result)
{
if (input == null)
{
return TimeSpanParse.TryParseExactMultiple(input, formats, formatProvider, TimeSpanStyles.None, out result);
}
- public static Boolean TryParseExact(String input, String format, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result)
+ public static bool TryParseExact(string input, string format, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result)
{
ValidateStyles(styles, nameof(styles));
if (input == null || format == null)
ValidateStyles(styles, nameof(styles));
return TimeSpanParse.TryParseExact(input, format, formatProvider, styles, out result);
}
- public static Boolean TryParseExact(String input, String[] formats, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result)
+ public static bool TryParseExact(string input, string[] formats, IFormatProvider formatProvider, TimeSpanStyles styles, out TimeSpan result)
{
ValidateStyles(styles, nameof(styles));
if (input == null)
ValidateStyles(styles, nameof(styles));
return TimeSpanParse.TryParseExactMultiple(input, formats, formatProvider, styles, out result);
}
- public override String ToString()
+ public override string ToString()
{
return TimeSpanFormat.Format(this, null, null);
}
- public String ToString(String format)
+ public string ToString(string format)
{
return TimeSpanFormat.Format(this, format, null);
}
- public String ToString(String format, IFormatProvider formatProvider)
+ public string ToString(string format, IFormatProvider formatProvider)
{
return TimeSpanFormat.Format(this, format, formatProvider);
}
private static volatile TimeZone currentTimeZone = null;
// Private object for locking instead of locking on a public type for SQL reliability work.
- private static Object s_InternalSyncObject;
- private static Object InternalSyncObject
+ private static object s_InternalSyncObject;
+ private static object InternalSyncObject
{
get
{
if (s_InternalSyncObject == null)
{
- Object o = new Object();
- Interlocked.CompareExchange<Object>(ref s_InternalSyncObject, o, null);
+ object o = new object();
+ Interlocked.CompareExchange<object>(ref s_InternalSyncObject, o, null);
}
return s_InternalSyncObject;
}
}
}
- public abstract String StandardName
+ public abstract string StandardName
{
get;
}
- public abstract String DaylightName
+ public abstract string DaylightName
{
get;
}
{
return time;
}
- Boolean isAmbiguousLocalDst = false;
- Int64 offset = ((CurrentSystemTimeZone)(TimeZone.CurrentTimeZone)).GetUtcOffsetFromUniversalTime(time, ref isAmbiguousLocalDst);
+ bool isAmbiguousLocalDst = false;
+ long offset = ((CurrentSystemTimeZone)(TimeZone.CurrentTimeZone)).GetUtcOffsetFromUniversalTime(time, ref isAmbiguousLocalDst);
return new DateTime(time.Ticks + offset, DateTimeKind.Local, isAmbiguousLocalDst);
}
ambiguousEnd = startTime - daylightTimes.Delta;
}
- Boolean isDst = false;
+ bool isDst = false;
if (startTime > endTime)
{
// In southern hemisphere, the daylight saving time starts later in the year, and ends in the beginning of next year.
{
}
- public TimeZoneNotFoundException(String message)
+ public TimeZoneNotFoundException(string message)
: base(message)
{
}
- public TimeZoneNotFoundException(String message, Exception innerException)
+ public TimeZoneNotFoundException(string message, Exception innerException)
: base(message, innerException)
{
}
HResult = HResults.COR_E_TIMEOUT;
}
- public TimeoutException(String message)
+ public TimeoutException(string message)
: base(message)
{
HResult = HResults.COR_E_TIMEOUT;
}
- public TimeoutException(String message, Exception innerException)
+ public TimeoutException(string message, Exception innerException)
: base(message, innerException)
{
HResult = HResults.COR_E_TIMEOUT;
m_Item1 = item1;
}
- public override Boolean Equals(Object obj)
+ public override bool Equals(object obj)
{
- return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<Object>.Default);
+ return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default);
}
- Boolean IStructuralEquatable.Equals(Object other, IEqualityComparer comparer)
+ bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
{
if (other == null) return false;
return comparer.Equals(m_Item1, objTuple.m_Item1);
}
- Int32 IComparable.CompareTo(Object obj)
+ int IComparable.CompareTo(object obj)
{
- return ((IStructuralComparable)this).CompareTo(obj, Comparer<Object>.Default);
+ return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
}
- Int32 IStructuralComparable.CompareTo(Object other, IComparer comparer)
+ int IStructuralComparable.CompareTo(object other, IComparer comparer)
{
if (other == null) return 1;
public override int GetHashCode()
{
- return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<Object>.Default);
+ return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
}
- Int32 IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
+ int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
{
return comparer.GetHashCode(m_Item1);
}
- Int32 ITupleInternal.GetHashCode(IEqualityComparer comparer)
+ int ITupleInternal.GetHashCode(IEqualityComparer comparer)
{
return ((IStructuralEquatable)this).GetHashCode(comparer);
}
m_Item2 = item2;
}
- public override Boolean Equals(Object obj)
+ public override bool Equals(object obj)
{
- return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<Object>.Default); ;
+ return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
}
- Boolean IStructuralEquatable.Equals(Object other, IEqualityComparer comparer)
+ bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
{
if (other == null) return false;
return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2);
}
- Int32 IComparable.CompareTo(Object obj)
+ int IComparable.CompareTo(object obj)
{
- return ((IStructuralComparable)this).CompareTo(obj, Comparer<Object>.Default);
+ return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
}
- Int32 IStructuralComparable.CompareTo(Object other, IComparer comparer)
+ int IStructuralComparable.CompareTo(object other, IComparer comparer)
{
if (other == null) return 1;
public override int GetHashCode()
{
- return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<Object>.Default);
+ return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
}
- Int32 IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
+ int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
{
return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2));
}
- Int32 ITupleInternal.GetHashCode(IEqualityComparer comparer)
+ int ITupleInternal.GetHashCode(IEqualityComparer comparer)
{
return ((IStructuralEquatable)this).GetHashCode(comparer);
}
m_Item3 = item3;
}
- public override Boolean Equals(Object obj)
+ public override bool Equals(object obj)
{
- return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<Object>.Default); ;
+ return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
}
- Boolean IStructuralEquatable.Equals(Object other, IEqualityComparer comparer)
+ bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
{
if (other == null) return false;
return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3);
}
- Int32 IComparable.CompareTo(Object obj)
+ int IComparable.CompareTo(object obj)
{
- return ((IStructuralComparable)this).CompareTo(obj, Comparer<Object>.Default);
+ return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
}
- Int32 IStructuralComparable.CompareTo(Object other, IComparer comparer)
+ int IStructuralComparable.CompareTo(object other, IComparer comparer)
{
if (other == null) return 1;
public override int GetHashCode()
{
- return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<Object>.Default);
+ return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
}
- Int32 IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
+ int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
{
return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3));
}
- Int32 ITupleInternal.GetHashCode(IEqualityComparer comparer)
+ int ITupleInternal.GetHashCode(IEqualityComparer comparer)
{
return ((IStructuralEquatable)this).GetHashCode(comparer);
}
m_Item4 = item4;
}
- public override Boolean Equals(Object obj)
+ public override bool Equals(object obj)
{
- return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<Object>.Default); ;
+ return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
}
- Boolean IStructuralEquatable.Equals(Object other, IEqualityComparer comparer)
+ bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
{
if (other == null) return false;
return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3) && comparer.Equals(m_Item4, objTuple.m_Item4);
}
- Int32 IComparable.CompareTo(Object obj)
+ int IComparable.CompareTo(object obj)
{
- return ((IStructuralComparable)this).CompareTo(obj, Comparer<Object>.Default);
+ return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
}
- Int32 IStructuralComparable.CompareTo(Object other, IComparer comparer)
+ int IStructuralComparable.CompareTo(object other, IComparer comparer)
{
if (other == null) return 1;
public override int GetHashCode()
{
- return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<Object>.Default);
+ return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
}
- Int32 IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
+ int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
{
return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4));
}
- Int32 ITupleInternal.GetHashCode(IEqualityComparer comparer)
+ int ITupleInternal.GetHashCode(IEqualityComparer comparer)
{
return ((IStructuralEquatable)this).GetHashCode(comparer);
}
m_Item5 = item5;
}
- public override Boolean Equals(Object obj)
+ public override bool Equals(object obj)
{
- return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<Object>.Default); ;
+ return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
}
- Boolean IStructuralEquatable.Equals(Object other, IEqualityComparer comparer)
+ bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
{
if (other == null) return false;
return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3) && comparer.Equals(m_Item4, objTuple.m_Item4) && comparer.Equals(m_Item5, objTuple.m_Item5);
}
- Int32 IComparable.CompareTo(Object obj)
+ int IComparable.CompareTo(object obj)
{
- return ((IStructuralComparable)this).CompareTo(obj, Comparer<Object>.Default);
+ return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
}
- Int32 IStructuralComparable.CompareTo(Object other, IComparer comparer)
+ int IStructuralComparable.CompareTo(object other, IComparer comparer)
{
if (other == null) return 1;
public override int GetHashCode()
{
- return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<Object>.Default);
+ return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
}
- Int32 IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
+ int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
{
return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5));
}
- Int32 ITupleInternal.GetHashCode(IEqualityComparer comparer)
+ int ITupleInternal.GetHashCode(IEqualityComparer comparer)
{
return ((IStructuralEquatable)this).GetHashCode(comparer);
}
m_Item6 = item6;
}
- public override Boolean Equals(Object obj)
+ public override bool Equals(object obj)
{
- return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<Object>.Default); ;
+ return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
}
- Boolean IStructuralEquatable.Equals(Object other, IEqualityComparer comparer)
+ bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
{
if (other == null) return false;
return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3) && comparer.Equals(m_Item4, objTuple.m_Item4) && comparer.Equals(m_Item5, objTuple.m_Item5) && comparer.Equals(m_Item6, objTuple.m_Item6);
}
- Int32 IComparable.CompareTo(Object obj)
+ int IComparable.CompareTo(object obj)
{
- return ((IStructuralComparable)this).CompareTo(obj, Comparer<Object>.Default);
+ return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
}
- Int32 IStructuralComparable.CompareTo(Object other, IComparer comparer)
+ int IStructuralComparable.CompareTo(object other, IComparer comparer)
{
if (other == null) return 1;
public override int GetHashCode()
{
- return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<Object>.Default);
+ return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
}
- Int32 IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
+ int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
{
return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6));
}
- Int32 ITupleInternal.GetHashCode(IEqualityComparer comparer)
+ int ITupleInternal.GetHashCode(IEqualityComparer comparer)
{
return ((IStructuralEquatable)this).GetHashCode(comparer);
}
m_Item7 = item7;
}
- public override Boolean Equals(Object obj)
+ public override bool Equals(object obj)
{
- return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<Object>.Default); ;
+ return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
}
- Boolean IStructuralEquatable.Equals(Object other, IEqualityComparer comparer)
+ bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
{
if (other == null) return false;
return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3) && comparer.Equals(m_Item4, objTuple.m_Item4) && comparer.Equals(m_Item5, objTuple.m_Item5) && comparer.Equals(m_Item6, objTuple.m_Item6) && comparer.Equals(m_Item7, objTuple.m_Item7);
}
- Int32 IComparable.CompareTo(Object obj)
+ int IComparable.CompareTo(object obj)
{
- return ((IStructuralComparable)this).CompareTo(obj, Comparer<Object>.Default);
+ return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
}
- Int32 IStructuralComparable.CompareTo(Object other, IComparer comparer)
+ int IStructuralComparable.CompareTo(object other, IComparer comparer)
{
if (other == null) return 1;
public override int GetHashCode()
{
- return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<Object>.Default);
+ return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
}
- Int32 IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
+ int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
{
return Tuple.CombineHashCodes(comparer.GetHashCode(m_Item1), comparer.GetHashCode(m_Item2), comparer.GetHashCode(m_Item3), comparer.GetHashCode(m_Item4), comparer.GetHashCode(m_Item5), comparer.GetHashCode(m_Item6), comparer.GetHashCode(m_Item7));
}
- Int32 ITupleInternal.GetHashCode(IEqualityComparer comparer)
+ int ITupleInternal.GetHashCode(IEqualityComparer comparer)
{
return ((IStructuralEquatable)this).GetHashCode(comparer);
}
m_Rest = rest;
}
- public override Boolean Equals(Object obj)
+ public override bool Equals(object obj)
{
- return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<Object>.Default); ;
+ return ((IStructuralEquatable)this).Equals(obj, EqualityComparer<object>.Default); ;
}
- Boolean IStructuralEquatable.Equals(Object other, IEqualityComparer comparer)
+ bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
{
if (other == null) return false;
return comparer.Equals(m_Item1, objTuple.m_Item1) && comparer.Equals(m_Item2, objTuple.m_Item2) && comparer.Equals(m_Item3, objTuple.m_Item3) && comparer.Equals(m_Item4, objTuple.m_Item4) && comparer.Equals(m_Item5, objTuple.m_Item5) && comparer.Equals(m_Item6, objTuple.m_Item6) && comparer.Equals(m_Item7, objTuple.m_Item7) && comparer.Equals(m_Rest, objTuple.m_Rest);
}
- Int32 IComparable.CompareTo(Object obj)
+ int IComparable.CompareTo(object obj)
{
- return ((IStructuralComparable)this).CompareTo(obj, Comparer<Object>.Default);
+ return ((IStructuralComparable)this).CompareTo(obj, Comparer<object>.Default);
}
- Int32 IStructuralComparable.CompareTo(Object other, IComparer comparer)
+ int IStructuralComparable.CompareTo(object other, IComparer comparer)
{
if (other == null) return 1;
public override int GetHashCode()
{
- return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<Object>.Default);
+ return ((IStructuralEquatable)this).GetHashCode(EqualityComparer<object>.Default);
}
- Int32 IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
+ int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
{
// We want to have a limited hash in this case. We'll use the last 8 elements of the tuple
ITupleInternal t = (ITupleInternal)m_Rest;
return -1;
}
- Int32 ITupleInternal.GetHashCode(IEqualityComparer comparer)
+ int ITupleInternal.GetHashCode(IEqualityComparer comparer)
{
return ((IStructuralEquatable)this).GetHashCode(comparer);
}
[CLSCompliant(false)]
[StructLayout(LayoutKind.Sequential)]
[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public struct UInt16 : IComparable, IConvertible, IFormattable, IComparable<UInt16>, IEquatable<UInt16>, ISpanFormattable
+ public struct UInt16 : IComparable, IConvertible, IFormattable, IComparable<ushort>, IEquatable<ushort>, ISpanFormattable
{
private ushort m_value; // Do not rename (binary serialization)
// null is considered to be less than any instance.
// If object is not of type UInt16, this method throws an ArgumentException.
//
- public int CompareTo(Object value)
+ public int CompareTo(object value)
{
if (value == null)
{
return 1;
}
- if (value is UInt16)
+ if (value is ushort)
{
- return ((int)m_value - (int)(((UInt16)value).m_value));
+ return ((int)m_value - (int)(((ushort)value).m_value));
}
throw new ArgumentException(SR.Arg_MustBeUInt16);
}
- public int CompareTo(UInt16 value)
+ public int CompareTo(ushort value)
{
return ((int)m_value - (int)value);
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
- if (!(obj is UInt16))
+ if (!(obj is ushort))
{
return false;
}
- return m_value == ((UInt16)obj).m_value;
+ return m_value == ((ushort)obj).m_value;
}
[NonVersionable]
- public bool Equals(UInt16 obj)
+ public bool Equals(ushort obj)
{
return m_value == obj;
}
}
// Converts the current value to a String in base-10 with no extra padding.
- public override String ToString()
+ public override string ToString()
{
return Number.FormatUInt32(m_value, null, null);
}
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
return Number.FormatUInt32(m_value, null, provider);
}
- public String ToString(String format)
+ public string ToString(string format)
{
return Number.FormatUInt32(m_value, format, null);
}
- public String ToString(String format, IFormatProvider provider)
+ public string ToString(string format, IFormatProvider provider)
{
return Number.FormatUInt32(m_value, format, provider);
}
}
[CLSCompliant(false)]
- public static ushort Parse(String s)
+ public static ushort Parse(string s)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
}
[CLSCompliant(false)]
- public static ushort Parse(String s, NumberStyles style)
+ public static ushort Parse(string s, NumberStyles style)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
[CLSCompliant(false)]
- public static ushort Parse(String s, IFormatProvider provider)
+ public static ushort Parse(string s, IFormatProvider provider)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Parse((ReadOnlySpan<char>)s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
}
[CLSCompliant(false)]
- public static ushort Parse(String s, NumberStyles style, IFormatProvider provider)
+ public static ushort Parse(string s, NumberStyles style, IFormatProvider provider)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
}
[CLSCompliant(false)]
- public static bool TryParse(String s, out UInt16 result)
+ public static bool TryParse(string s, out ushort result)
{
if (s == null)
{
}
[CLSCompliant(false)]
- public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out UInt16 result)
+ public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out ushort result)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
return TryParse(s, style, NumberFormatInfo.GetInstance(provider), out result);
}
- private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out UInt16 result)
+ private static bool TryParse(ReadOnlySpan<char> s, NumberStyles style, NumberFormatInfo info, out ushort result)
{
result = 0;
- UInt32 i;
+ uint i;
if (!Number.TryParseUInt32(s, style, info, out i))
{
return false;
{
return false;
}
- result = (UInt16)i;
+ result = (ushort)i;
return true;
}
return Convert.ToDouble(m_value);
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
return Convert.ToDecimal(m_value);
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "UInt16", "DateTime"));
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
[CLSCompliant(false)]
[StructLayout(LayoutKind.Sequential)]
[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public struct UInt32 : IComparable, IConvertible, IFormattable, IComparable<UInt32>, IEquatable<UInt32>, ISpanFormattable
+ public struct UInt32 : IComparable, IConvertible, IFormattable, IComparable<uint>, IEquatable<uint>, ISpanFormattable
{
private uint m_value; // Do not rename (binary serialization)
// null is considered to be less than any instance.
// If object is not of type UInt32, this method throws an ArgumentException.
//
- public int CompareTo(Object value)
+ public int CompareTo(object value)
{
if (value == null)
{
return 1;
}
- if (value is UInt32)
+ if (value is uint)
{
// Need to use compare because subtraction will wrap
// to positive for very large neg numbers, etc.
throw new ArgumentException(SR.Arg_MustBeUInt32);
}
- public int CompareTo(UInt32 value)
+ public int CompareTo(uint value)
{
// Need to use compare because subtraction will wrap
// to positive for very large neg numbers, etc.
return 0;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
- if (!(obj is UInt32))
+ if (!(obj is uint))
{
return false;
}
- return m_value == ((UInt32)obj).m_value;
+ return m_value == ((uint)obj).m_value;
}
[NonVersionable]
- public bool Equals(UInt32 obj)
+ public bool Equals(uint obj)
{
return m_value == obj;
}
}
// The base 10 representation of the number with no extra padding.
- public override String ToString()
+ public override string ToString()
{
return Number.FormatUInt32(m_value, null, null);
}
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
return Number.FormatUInt32(m_value, null, provider);
}
- public String ToString(String format)
+ public string ToString(string format)
{
return Number.FormatUInt32(m_value, format, null);
}
- public String ToString(String format, IFormatProvider provider)
+ public string ToString(string format, IFormatProvider provider)
{
return Number.FormatUInt32(m_value, format, provider);
}
}
[CLSCompliant(false)]
- public static uint Parse(String s)
+ public static uint Parse(string s)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseUInt32(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
}
[CLSCompliant(false)]
- public static uint Parse(String s, NumberStyles style)
+ public static uint Parse(string s, NumberStyles style)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
[CLSCompliant(false)]
- public static uint Parse(String s, IFormatProvider provider)
+ public static uint Parse(string s, IFormatProvider provider)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseUInt32(s, NumberStyles.Integer, NumberFormatInfo.GetInstance(provider));
}
[CLSCompliant(false)]
- public static uint Parse(String s, NumberStyles style, IFormatProvider provider)
+ public static uint Parse(string s, NumberStyles style, IFormatProvider provider)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
}
[CLSCompliant(false)]
- public static bool TryParse(String s, out UInt32 result)
+ public static bool TryParse(string s, out uint result)
{
if (s == null)
{
}
[CLSCompliant(false)]
- public static bool TryParse(String s, NumberStyles style, IFormatProvider provider, out UInt32 result)
+ public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out uint result)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
return Convert.ToDouble(m_value);
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
return Convert.ToDecimal(m_value);
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "UInt32", "DateTime"));
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
[CLSCompliant(false)]
[StructLayout(LayoutKind.Sequential)]
[TypeForwardedFrom("mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089")]
- public struct UInt64 : IComparable, IConvertible, IFormattable, IComparable<UInt64>, IEquatable<UInt64>, ISpanFormattable
+ public struct UInt64 : IComparable, IConvertible, IFormattable, IComparable<ulong>, IEquatable<ulong>, ISpanFormattable
{
private ulong m_value; // Do not rename (binary serialization)
// null is considered to be less than any instance.
// If object is not of type UInt64, this method throws an ArgumentException.
//
- public int CompareTo(Object value)
+ public int CompareTo(object value)
{
if (value == null)
{
return 1;
}
- if (value is UInt64)
+ if (value is ulong)
{
// Need to use compare because subtraction will wrap
// to positive for very large neg numbers, etc.
throw new ArgumentException(SR.Arg_MustBeUInt64);
}
- public int CompareTo(UInt64 value)
+ public int CompareTo(ulong value)
{
// Need to use compare because subtraction will wrap
// to positive for very large neg numbers, etc.
return 0;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
- if (!(obj is UInt64))
+ if (!(obj is ulong))
{
return false;
}
- return m_value == ((UInt64)obj).m_value;
+ return m_value == ((ulong)obj).m_value;
}
[NonVersionable]
- public bool Equals(UInt64 obj)
+ public bool Equals(ulong obj)
{
return m_value == obj;
}
return ((int)m_value) ^ (int)(m_value >> 32);
}
- public override String ToString()
+ public override string ToString()
{
return Number.FormatUInt64(m_value, null, null);
}
- public String ToString(IFormatProvider provider)
+ public string ToString(IFormatProvider provider)
{
return Number.FormatUInt64(m_value, null, provider);
}
- public String ToString(String format)
+ public string ToString(string format)
{
return Number.FormatUInt64(m_value, format, null);
}
- public String ToString(String format, IFormatProvider provider)
+ public string ToString(string format, IFormatProvider provider)
{
return Number.FormatUInt64(m_value, format, provider);
}
}
[CLSCompliant(false)]
- public static ulong Parse(String s)
+ public static ulong Parse(string s)
{
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
return Number.ParseUInt64(s, NumberStyles.Integer, NumberFormatInfo.CurrentInfo);
}
[CLSCompliant(false)]
- public static ulong Parse(String s, NumberStyles style)
+ public static ulong Parse(string s, NumberStyles style)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
}
[CLSCompliant(false)]
- public static ulong Parse(String s, NumberStyles style, IFormatProvider provider)
+ public static ulong Parse(string s, NumberStyles style, IFormatProvider provider)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
if (s == null) ThrowHelper.ThrowArgumentNullException(ExceptionArgument.s);
}
[CLSCompliant(false)]
- public static Boolean TryParse(String s, out UInt64 result)
+ public static bool TryParse(string s, out ulong result)
{
if (s == null)
{
}
[CLSCompliant(false)]
- public static Boolean TryParse(String s, NumberStyles style, IFormatProvider provider, out UInt64 result)
+ public static bool TryParse(string s, NumberStyles style, IFormatProvider provider, out ulong result)
{
NumberFormatInfo.ValidateParseStyleInteger(style);
return Convert.ToDouble(m_value);
}
- Decimal IConvertible.ToDecimal(IFormatProvider provider)
+ decimal IConvertible.ToDecimal(IFormatProvider provider)
{
return Convert.ToDecimal(m_value);
}
throw new InvalidCastException(SR.Format(SR.InvalidCast_FromTo, "UInt64", "DateTime"));
}
- Object IConvertible.ToType(Type type, IFormatProvider provider)
+ object IConvertible.ToType(Type type, IFormatProvider provider)
{
return Convert.DefaultToType((IConvertible)this, type, provider);
}
info.AddValue("value", ToUInt64());
}
- public unsafe override bool Equals(Object obj)
+ public unsafe override bool Equals(object obj)
{
if (obj is UIntPtr)
{
HResult = HResults.COR_E_UNAUTHORIZEDACCESS;
}
- public UnauthorizedAccessException(String message)
+ public UnauthorizedAccessException(string message)
: base(message)
{
HResult = HResults.COR_E_UNAUTHORIZEDACCESS;
}
- public UnauthorizedAccessException(String message, Exception inner)
+ public UnauthorizedAccessException(string message, Exception inner)
: base(message, inner)
{
HResult = HResults.COR_E_UNAUTHORIZEDACCESS;
{
public class UnhandledExceptionEventArgs : EventArgs
{
- private Object _exception;
+ private object _exception;
private bool _isTerminating;
- public UnhandledExceptionEventArgs(Object exception, bool isTerminating)
+ public UnhandledExceptionEventArgs(object exception, bool isTerminating)
{
_exception = exception;
_isTerminating = isTerminating;
}
- public Object ExceptionObject
+ public object ExceptionObject
{
get { return _exception; }
}
namespace System
{
- public delegate void UnhandledExceptionEventHandler(Object sender, UnhandledExceptionEventArgs e);
+ public delegate void UnhandledExceptionEventHandler(object sender, UnhandledExceptionEventArgs e);
}
_Minor = minor;
}
- public Version(String version)
+ public Version(string version)
{
Version v = Version.Parse(version);
_Major = v.Major;
get { return (short)(_Revision & 0xFFFF); }
}
- public int CompareTo(Object version)
+ public int CompareTo(object version)
{
if (version == null)
{
0;
}
- public override bool Equals(Object obj)
+ public override bool Equals(object obj)
{
return Equals(obj as Version);
}
public static bool operator <(Version v1, Version v2)
{
- if ((Object)v1 == null)
+ if ((object)v1 == null)
throw new ArgumentNullException(nameof(v1));
return (v1.CompareTo(v2) < 0);
}
public static bool operator <=(Version v1, Version v2)
{
- if ((Object)v1 == null)
+ if ((object)v1 == null)
throw new ArgumentNullException(nameof(v1));
return (v1.CompareTo(v2) <= 0);
}
projects / platform / upstream / dotnet / runtime.git / commitdiff