public string TypeName;
[CLSCompliant(false)]
- public unsafe static ComActivationContext Create(ref ComActivationContextInternal cxtInt)
+ public static unsafe ComActivationContext Create(ref ComActivationContextInternal cxtInt)
{
return new ComActivationContext()
{
/// </summary>
/// <param name="cxtInt">Reference to a <see cref="ComActivationContextInternal"/> instance</param>
[CLSCompliant(false)]
- public unsafe static int GetClassFactoryForTypeInternal(ref ComActivationContextInternal cxtInt)
+ public static unsafe int GetClassFactoryForTypeInternal(ref ComActivationContextInternal cxtInt)
{
if (IsLoggingEnabled())
{
/// </summary>
/// <param name="cxtInt">Reference to a <see cref="ComActivationContextInternal"/> instance</param>
[CLSCompliant(false)]
- public unsafe static int RegisterClassForTypeInternal(ref ComActivationContextInternal cxtInt)
+ public static unsafe int RegisterClassForTypeInternal(ref ComActivationContextInternal cxtInt)
{
if (IsLoggingEnabled())
{
/// Internal entry point for unregistering a managed COM server API from native code
/// </summary>
[CLSCompliant(false)]
- public unsafe static int UnregisterClassForTypeInternal(ref ComActivationContextInternal cxtInt)
+ public static unsafe int UnregisterClassForTypeInternal(ref ComActivationContextInternal cxtInt)
{
if (IsLoggingEnabled())
{
/// <param name="componentPath">The path to the WinRT component that the type is expected to be defined in.</param>
/// <param name="typeName">The name of the component type to activate</param>
/// <param name="activationFactory">The activation factory</param>
- public unsafe static int GetActivationFactory(
+ public static unsafe int GetActivationFactory(
char* componentPath,
[MarshalAs(UnmanagedType.HString)] string typeName,
[MarshalAs(UnmanagedType.Interface)] out IActivationFactory? activationFactory)
{
#if FEATURE_APPX
// Cache the value in readonly static that can be optimized out by the JIT
- internal readonly static bool IsUap = IsAppXProcess() != Interop.BOOL.FALSE;
+ internal static readonly bool IsUap = IsAppXProcess() != Interop.BOOL.FALSE;
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
private static extern Interop.BOOL IsAppXProcess();
public readonly partial struct DateTime
{
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static unsafe extern bool ValidateSystemTime(Interop.Kernel32.SYSTEMTIME* time, bool localTime);
+ private static extern unsafe bool ValidateSystemTime(Interop.Kernel32.SYSTEMTIME* time, bool localTime);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static unsafe extern bool FileTimeToSystemTime(long fileTime, FullSystemTime* time);
+ private static extern unsafe bool FileTimeToSystemTime(long fileTime, FullSystemTime* time);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static unsafe extern void GetSystemTimeWithLeapSecondsHandling(FullSystemTime* time);
+ private static extern unsafe void GetSystemTimeWithLeapSecondsHandling(FullSystemTime* time);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static unsafe extern bool SystemTimeToFileTime(Interop.Kernel32.SYSTEMTIME* time, long* fileTime);
+ private static extern unsafe bool SystemTimeToFileTime(Interop.Kernel32.SYSTEMTIME* time, long* fileTime);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- private static unsafe extern long GetSystemTimeAsFileTime();
+ private static extern unsafe long GetSystemTimeAsFileTime();
}
}
}
}
- internal protected override void OnEventSourceCreated(EventSource eventSource)
+ protected internal override void OnEventSourceCreated(EventSource eventSource)
{
// Don't enable forwarding of NativeRuntimeEventSource events.`
if (eventSource.GetType() == typeof(NativeRuntimeEventSource))
}
}
- internal protected override void OnEventWritten(EventWrittenEventArgs eventData)
+ protected internal override void OnEventWritten(EventWrittenEventArgs eventData)
{
string? eventFilter = eventSourceEventFilter.Value;
if (string.IsNullOrEmpty(eventFilter) || (eventData.EventName!.IndexOf(eventFilter, StringComparison.OrdinalIgnoreCase) >= 0))
private static extern void GetEnumValuesAndNames(QCallTypeHandle enumType, ObjectHandleOnStack values, ObjectHandleOnStack names, Interop.BOOL getNames);
[MethodImpl(MethodImplOptions.InternalCall)]
- public override extern bool Equals(object? obj);
+ public extern override bool Equals(object? obj);
[MethodImpl(MethodImplOptions.InternalCall)]
private static extern object InternalBoxEnum(RuntimeType enumType, long value);
private static class WinRT
{
// Cache the value in readonly static that can be optimized out by the JIT
- public readonly static bool IsSupported = WinRTSupported() != Interop.BOOL.FALSE;
+ public static readonly bool IsSupported = WinRTSupported() != Interop.BOOL.FALSE;
}
// Does the current version of Windows have Windows Runtime suppport?
#endif // FEATURE_COMINTEROP
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- static private extern IRuntimeMethodInfo GetMethodFromStackTrace(object stackTrace);
+ private static extern IRuntimeMethodInfo GetMethodFromStackTrace(object stackTrace);
private MethodBase? GetExceptionMethodFromStackTrace()
{
// 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 sealed override bool Equals(object? obj)
{
if (obj == null)
return false;
// This method will combine this delegate with the passed delegate
// to form a new delegate.
- protected override sealed Delegate CombineImpl(Delegate? follow)
+ protected sealed override Delegate CombineImpl(Delegate? follow)
{
if ((object?)follow == null) // cast to object for a more efficient test
return this;
// look at the invocation list.) If this is found we remove it from
// this list and return a new delegate. If its not found a copy of the
// current list is returned.
- protected override sealed Delegate? RemoveImpl(Delegate value)
+ protected sealed override Delegate? RemoveImpl(Delegate value)
{
// There is a special case were we are removing using a delegate as
// the value we need to check for this case
}
// This method returns the Invocation list of this multicast delegate.
- public override sealed Delegate[] GetInvocationList()
+ public sealed override Delegate[] GetInvocationList()
{
Delegate[] del;
if (!(_invocationList is object[] invocationList))
return ReferenceEquals(d2, d1) ? false : !d2.Equals(d1);
}
- public override sealed int GetHashCode()
+ public sealed override int GetHashCode()
{
if (IsUnmanagedFunctionPtr())
return ValueType.GetHashCodeOfPtr(_methodPtr) ^ ValueType.GetHashCodeOfPtr(_methodPtrAux);
namespace System.Reflection.Emit
{
- sealed public class EnumBuilder : TypeInfo
+ public sealed class EnumBuilder : TypeInfo
{
public override bool IsAssignableFrom(TypeInfo? typeInfo)
{
{
}
- override protected bool ReleaseHandle()
+ protected override bool ReleaseHandle()
{
m_Release(handle);
return true;
namespace System.Reflection
{
- internal unsafe sealed class RtFieldInfo : RuntimeFieldInfo, IRuntimeFieldInfo
+ internal sealed unsafe class RtFieldInfo : RuntimeFieldInfo, IRuntimeFieldInfo
{
#region Private Data Members
// aggressive caching
return GetManifestResourceStream(resourceName);
}
- public unsafe override Stream? GetManifestResourceStream(string name)
+ public override unsafe Stream? GetManifestResourceStream(string name)
{
uint length = 0;
RuntimeAssembly runtimeAssembly = this;
namespace System.Reflection
{
- internal unsafe sealed class RuntimeEventInfo : EventInfo
+ internal sealed unsafe class RuntimeEventInfo : EventInfo
{
#region Private Data Members
private int m_token;
namespace System.Reflection
{
- internal unsafe sealed class RuntimeParameterInfo : ParameterInfo
+ internal sealed unsafe class RuntimeParameterInfo : ParameterInfo
{
#region Static Members
internal static unsafe ParameterInfo[] GetParameters(IRuntimeMethodInfo method, MemberInfo member, Signature sig)
namespace System.Reflection
{
- internal unsafe sealed class RuntimePropertyInfo : PropertyInfo
+ internal sealed unsafe class RuntimePropertyInfo : PropertyInfo
{
#region Private Data Members
private int m_token;
public static extern int GetHashCode(object o);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
- public new static extern bool Equals(object? o1, object? o2);
+ public static extern new bool Equals(object? o1, object? o2);
public static int OffsetToStringData
{
return false;
}
- unsafe public void CopyFromIndirect(object value)
+ public unsafe void CopyFromIndirect(object value)
{
VarEnum vt = (VarEnum)(((int)this.VariantType) & ~((int)VarEnum.VT_BYREF));
// If the delegates aren't alive, it means either they have been unsubscribed, or the object itself is gone,
// and in either case, they've been already taken care of.
//
- internal volatile static
+ internal static volatile
ConditionalWeakTable<object, Dictionary<MethodInfo, Dictionary<object, EventRegistrationTokenList>>> s_eventRegistrations =
new ConditionalWeakTable<object, Dictionary<MethodInfo, Dictionary<object, EventRegistrationTokenList>>>();
// b. The same delegate is subscribed then unsubscribed. We need to make sure give
// them the latest token in this case. This is guaranteed by always giving the last token and always use equality to
// add/remove event handlers
- internal volatile static Dictionary<EventCacheKey, EventCacheEntry> s_eventRegistrations =
+ internal static volatile Dictionary<EventCacheKey, EventCacheEntry> s_eventRegistrations =
new Dictionary<EventCacheKey, EventCacheEntry>();
// Prevent add/remove handler code to run at the same with with cache cleanup code
- private volatile static MyReaderWriterLock s_eventCacheRWLock = new MyReaderWriterLock();
+ private static volatile MyReaderWriterLock s_eventCacheRWLock = new MyReaderWriterLock();
// Get InstanceKey to use in the cache
private static object GetInstanceKey(Action<EventRegistrationToken> removeMethod)
}
[DllImport(JitHelpers.QCall, CharSet = CharSet.Unicode)]
- private unsafe static extern void GetPEKind(QCallModule handle, int *peKind, int *machine);
+ private static extern unsafe void GetPEKind(QCallModule handle, int *peKind, int *machine);
// making this internal, used by Module.GetPEKind
- internal unsafe static void GetPEKind(RuntimeModule module, out PortableExecutableKinds peKind, out ImageFileMachine machine)
+ internal static unsafe void GetPEKind(RuntimeModule module, out PortableExecutableKinds peKind, out ImageFileMachine machine)
{
int lKind, lMachine;
GetPEKind(JitHelpers.GetQCallModuleOnStack(ref module), &lKind, &lMachine);
{
// The length of the returned array is an approximation based on the length of the input string and the system
// character set. It is only guaranteed to be larger or equal to cbLength, don't depend on the exact value.
- unsafe internal static byte[] DoAnsiConversion(string str, bool fBestFit, bool fThrowOnUnmappableChar, out int cbLength)
+ internal static unsafe byte[] DoAnsiConversion(string str, bool fBestFit, bool fThrowOnUnmappableChar, out int cbLength)
{
byte[] buffer = new byte[checked((str.Length + 1) * Marshal.SystemMaxDBCSCharSize)];
fixed (byte* bufferPtr = &buffer[0])
return buffer;
}
- unsafe internal static byte ConvertToNative(char managedChar, bool fBestFit, bool fThrowOnUnmappableChar)
+ internal static unsafe byte ConvertToNative(char managedChar, bool fBestFit, bool fThrowOnUnmappableChar)
{
int cbAllocLength = (1 + 1) * Marshal.SystemMaxDBCSCharSize;
byte* bufferPtr = stackalloc byte[cbAllocLength];
#region class OverlappedData
- sealed internal unsafe class OverlappedData
+ internal sealed unsafe class OverlappedData
{
// ! If you make any change to the layout here, you need to make matching change
// ! to OverlappedDataObject in vm\nativeoverlapped.h
}
[MethodImpl(MethodImplOptions.InternalCall)]
- private static unsafe extern int WaitMultipleIgnoringSyncContext(IntPtr *waitHandles, int numHandles, bool waitAll, int millisecondsTimeout);
+ private static extern unsafe int WaitMultipleIgnoringSyncContext(IntPtr *waitHandles, int numHandles, bool waitAll, int millisecondsTimeout);
private static int SignalAndWaitCore(IntPtr waitHandleToSignal, IntPtr waitHandleToWaitOn, int millisecondsTimeout)
{
// Protected routine to determine if this class represents a Windows Runtime object
- virtual internal bool IsWindowsRuntimeObjectImpl()
+ internal virtual bool IsWindowsRuntimeObjectImpl()
{
throw new NotImplementedException();
}
// Determines if this type is exported to WinRT (i.e. is an activatable class in a managed .winmd)
- virtual internal bool IsExportedToWindowsRuntimeImpl()
+ internal virtual bool IsExportedToWindowsRuntimeImpl()
{
throw new NotImplementedException();
}
/// </remarks>
[MethodImpl(MethodImplOptions.InternalCall)]
[CLSCompliant(false)]
- public unsafe extern Utf8String(byte* value);
+ public extern unsafe Utf8String(byte* value);
#if !CORECLR
static
/// </remarks>
[MethodImpl(MethodImplOptions.InternalCall)]
[CLSCompliant(false)]
- public unsafe extern Utf8String(char* value);
+ public extern unsafe Utf8String(char* value);
#if !CORECLR
static
internal ThreadPoolBoundHandle? ThreadPoolBinding { get; set; }
- override protected bool ReleaseHandle()
+ protected override bool ReleaseHandle()
{
return Interop.Kernel32.CloseHandle(handle);
}
{
internal SafeFindHandle() : base(true) { }
- override protected bool ReleaseHandle()
+ protected override bool ReleaseHandle()
{
return Interop.Kernel32.FindClose(handle);
}
return IndexOf(source, value, startIndex, count, CompareOptions.None);
}
- public unsafe virtual int IndexOf(string source, char value, int startIndex, int count, CompareOptions options)
+ public virtual unsafe int IndexOf(string source, char value, int startIndex, int count, CompareOptions options)
{
if (source == null)
{
return IndexOf(source, char.ToString(value), startIndex, count, options, null);
}
- public unsafe virtual int IndexOf(string source, string value, int startIndex, int count, CompareOptions options)
+ public virtual unsafe int IndexOf(string source, string value, int startIndex, int count, CompareOptions options)
{
if (source == null)
{
return s_Invariant;
}
}
- private volatile static CultureData? s_Invariant;
+ private static volatile CultureData? s_Invariant;
// Cache of cultures we've already looked up
private static volatile StringCultureDataDictionary? s_cachedCultures;
get => s_invariant ?? (s_invariant = new TextInfo(CultureData.Invariant));
}
- private volatile static TextInfo? s_invariant;
+ private static volatile TextInfo? s_invariant;
internal TextInfo(CultureData cultureData)
{
// advanced by two.
// Note this method cannot handle surrogates properly in UTF-8.
//
- public unsafe virtual void Write(char ch)
+ public virtual unsafe void Write(char ch)
{
if (char.IsSurrogate(ch))
throw new ArgumentException(SR.Arg_SurrogatesNotAllowedAsSingleChar);
// Writes a double to this stream. The current position of the stream is
// advanced by eight.
//
- public unsafe virtual void Write(double value)
+ public virtual unsafe void Write(double value)
{
ulong TmpValue = *(ulong*)&value;
_buffer[0] = (byte)TmpValue;
// Writes a float to this stream. The current position of the stream is
// advanced by four.
//
- public unsafe virtual void Write(float value)
+ public virtual unsafe void Write(float value)
{
uint TmpValue = *(uint*)&value;
_buffer[0] = (byte)TmpValue;
// a four-byte unsigned integer, and then writes that many characters
// to the stream.
//
- public unsafe virtual void Write(string value)
+ public virtual unsafe void Write(string value)
{
if (value == null)
throw new ArgumentNullException(nameof(value));
this, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
}
- public async virtual Task<string> ReadToEndAsync()
+ public virtual async Task<string> ReadToEndAsync()
{
var sb = new StringBuilder(4096);
char[] chars = ArrayPool<char>.Shared.Rent(4096);
return _unmanagedStream.Seek(offset, loc);
}
- public unsafe override byte[] ToArray()
+ public override unsafe byte[] ToArray()
{
byte[] buffer = new byte[_unmanagedStream.Length];
_unmanagedStream.Read(buffer, 0, (int)_unmanagedStream.Length);
}
// Writes this MemoryStream to another stream.
- public unsafe override void WriteTo(Stream stream)
+ public override unsafe void WriteTo(Stream stream)
{
if (stream == null)
throw new ArgumentNullException(nameof(stream), SR.ArgumentNull_Stream);
info.AddValue("value", ToInt64());
}
- public unsafe override bool Equals(object? obj)
+ public override unsafe bool Equals(object? obj)
{
if (obj is IntPtr)
{
return _value == other._value;
}
- public unsafe override int GetHashCode()
+ public override unsafe int GetHashCode()
{
#if BIT64
long l = (long)_value;
return _value;
}
- public unsafe override string ToString()
+ public override unsafe string ToString()
{
return ((nint)_value).ToString(CultureInfo.InvariantCulture);
}
return bstr;
}
- override protected bool ReleaseHandle()
+ protected override bool ReleaseHandle()
{
RuntimeImports.RhZeroMemory(handle, (UIntPtr)Marshal.SysStringByteLen(handle));
Interop.OleAut32.SysFreeString(handle);
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
[CLSCompliant(false)]
- public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
+ public override unsafe int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
{
// Validate Parameters
}
// This version just counts the fallback and doesn't actually copy anything.
- internal unsafe override int InternalFallback(byte[] bytes, byte* pBytes)
+ internal override unsafe int InternalFallback(byte[] bytes, byte* pBytes)
// Right now this has both bytes and bytes[], since we might have extra bytes, hence the
// array, and we might need the index, hence the byte*
{
// Right now this has both bytes and bytes[], since we might have extra bytes, hence the
// array, and we might need the index, hence the byte*
// Don't touch ref chars unless we succeed
- internal unsafe virtual bool InternalFallback(byte[] bytes, byte* pBytes, ref char* chars)
+ internal virtual unsafe bool InternalFallback(byte[] bytes, byte* pBytes, ref char* chars)
{
Debug.Assert(byteStart != null, "[DecoderFallback.InternalFallback]Used InternalFallback without calling InternalInitialize");
}
// This version just counts the fallback and doesn't actually copy anything.
- internal unsafe virtual int InternalFallback(byte[] bytes, byte* pBytes)
+ internal virtual unsafe int InternalFallback(byte[] bytes, byte* pBytes)
// Right now this has both bytes and bytes[], since we might have extra bytes, hence the
// array, and we might need the index, hence the byte*
{
return GetCharCount(pBytes + index, count, flush);
}
- public unsafe override int GetCharCount(byte* bytes, int count, bool flush)
+ public override unsafe int GetCharCount(byte* bytes, int count, bool flush)
{
// Validate parameters
if (bytes == null)
pChars + charIndex, charCount, flush);
}
- public unsafe override int GetChars(byte* bytes, int byteCount,
+ public override unsafe int GetChars(byte* bytes, int byteCount,
char* chars, int charCount, bool flush)
{
// Validate parameters
// This is the version that used pointers. We call the base encoding worker function
// after setting our appropriate internal variables. This is getting chars
- public unsafe override void Convert(byte* bytes, int byteCount,
+ public override unsafe void Convert(byte* bytes, int byteCount,
char* chars, int charCount, bool flush,
out int bytesUsed, out int charsUsed, out bool completed)
{
}
// This version just counts the fallback and doesn't actually copy anything.
- internal unsafe override int InternalFallback(byte[] bytes, byte* pBytes)
+ internal override unsafe int InternalFallback(byte[] bytes, byte* pBytes)
// Right now this has both bytes and bytes[], since we might have extra bytes, hence the
// array, and we might need the index, hence the byte*
{
// Note that this could also change the contents of this.encoder, which is the same
// object that the caller is using, so the caller could mess up the encoder for us
// if they aren't careful.
- internal unsafe virtual bool InternalFallback(char ch, ref char* chars)
+ internal virtual unsafe bool InternalFallback(char ch, ref char* chars)
{
// Shouldn't have null charStart
Debug.Assert(charStart != null,
return result;
}
- public unsafe override int GetByteCount(char* chars, int count, bool flush)
+ public override unsafe int GetByteCount(char* chars, int count, bool flush)
{
// Validate input parameters
if (chars == null)
pBytes + byteIndex, byteCount, flush);
}
- public unsafe override int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, bool flush)
+ public override unsafe int GetBytes(char* chars, int charCount, byte* bytes, int byteCount, bool flush)
{
// Validate parameters
if (chars == null || bytes == null)
return _encoding.GetByteCount(chars, index, count);
}
- public unsafe override int GetByteCount(char* chars, int count, bool flush)
+ public override unsafe int GetByteCount(char* chars, int count, bool flush)
{
return _encoding.GetByteCount(chars, count);
}
return _encoding.GetBytes(chars, charIndex, charCount, bytes, byteIndex);
}
- public unsafe override int GetBytes(char* chars, int charCount,
+ public override unsafe int GetBytes(char* chars, int charCount,
byte* bytes, int byteCount, bool flush)
{
return _encoding.GetBytes(chars, charCount, bytes, byteCount);
return _encoding.GetCharCount(bytes, index, count);
}
- public unsafe override int GetCharCount(byte* bytes, int count, bool flush)
+ public override unsafe int GetCharCount(byte* bytes, int count, bool flush)
{
// By default just call the encoding version, no flush by default
return _encoding.GetCharCount(bytes, count);
return _encoding.GetChars(bytes, byteIndex, byteCount, chars, charIndex);
}
- public unsafe override int GetChars(byte* bytes, int byteCount,
+ public override unsafe int GetChars(byte* bytes, int byteCount,
char* chars, int charCount, bool flush)
{
// By default just call the encoding's version
// 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 unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
+ public override unsafe int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
{
// Validate Parameters
if (bytes == null || chars == null)
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
[CLSCompliant(false)]
- public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
+ public override unsafe int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
{
// Validate Parameters
if (bytes == null || chars == null)
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
[CLSCompliant(false)]
- public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
+ public override unsafe int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
{
// Validate Parameters
if (bytes == null || chars == null)
}
// This version just counts the fallback and doesn't actually copy anything.
- internal unsafe override int InternalFallback(byte[] bytes, byte* pBytes)
+ internal override unsafe int InternalFallback(byte[] bytes, byte* pBytes)
// Right now this has both bytes and bytes[], since we might have extra bytes, hence the
// array, and we might need the index, hence the byte*
{
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
[CLSCompliant(false)]
- public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
+ public override unsafe int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
{
// Validate Parameters
// EncodingNLS, UTF7Encoding, UTF8Encoding, UTF32Encoding, ASCIIEncoding, UnicodeEncoding
[CLSCompliant(false)]
- public unsafe override int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
+ public override unsafe int GetChars(byte* bytes, int byteCount, char* chars, int charCount)
{
// Validate Parameters
if (bytes == null || chars == null)
public abstract string? FullName { get; }
public abstract Assembly Assembly { get; }
- public abstract new Module Module { get; }
+ public new abstract Module Module { get; }
public bool IsNested => DeclaringType != null;
public override Type? DeclaringType => null;
info.AddValue("value", ToUInt64());
}
- public unsafe override bool Equals(object? obj)
+ public override unsafe bool Equals(object? obj)
{
if (obj is UIntPtr)
{
return _value == other._value;
}
- public unsafe override int GetHashCode()
+ public override unsafe int GetHashCode()
{
#if BIT64
ulong l = (ulong)_value;
return _value;
}
- public unsafe override string ToString()
+ public override unsafe string ToString()
{
return ((nuint)_value).ToString(CultureInfo.InvariantCulture);
}
projects / platform / upstream / dotnet / runtime.git / commitdiff