unsafe void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
{
ArgumentNullException.ThrowIfNull(info);
info.AddValue("value", ToInt64());
}
public static string?GetEnvironmentVariable(string variable)
{
ArgumentNullException.ThrowIfNull(variable);
return(GetEnvironmentVariableCore(variable));
}
public static void SuppressFinalize(object obj)
{
ArgumentNullException.ThrowIfNull(obj);
_SuppressFinalize(obj);
}
public static void ReRegisterForFinalize(object obj)
{
ArgumentNullException.ThrowIfNull(obj);
_ReRegisterForFinalize(obj);
}
/// <summary>
/// Format the given object in the current culture. This static method may be
/// imported in C# by
/// <code>
/// using static System.FormattableString;
/// </code>.
/// Within the scope
/// of that import directive an interpolated string may be formatted in the
/// current culture by writing, for example,
/// <code>
/// CurrentCulture($"{{ lat = {latitude}; lon = {longitude} }}")
/// </code>
/// </summary>
public static string CurrentCulture(FormattableString formattable)
{
ArgumentNullException.ThrowIfNull(formattable);
return(formattable.ToString(Globalization.CultureInfo.CurrentCulture));
}
public static string Normalize(this string strInput, NormalizationForm normalizationForm)
{
ArgumentNullException.ThrowIfNull(strInput);
return(strInput.Normalize(normalizationForm));
}
public override object?InvokeMember(
string name, BindingFlags bindingFlags, Binder?binder, object?target,
object?[]?providedArgs, ParameterModifier[]?modifiers, CultureInfo?culture, string[]?namedParams)
{
ArgumentNullException.ThrowIfNull(name);
const BindingFlags MemberBindingMask = (BindingFlags)0x000000FF;
const BindingFlags InvocationMask = (BindingFlags)0x0000FF00;
const BindingFlags BinderGetSetField = BindingFlags.GetField | BindingFlags.SetField;
const BindingFlags BinderGetSetProperty = BindingFlags.GetProperty | BindingFlags.SetProperty;
const BindingFlags BinderNonCreateInstance = BindingFlags.InvokeMethod | BinderGetSetField | BinderGetSetProperty;
const BindingFlags BinderNonFieldGetSet = (BindingFlags)0x00FFF300;
if (IsGenericParameter)
{
throw new InvalidOperationException(SR.Arg_GenericParameter);
}
if ((bindingFlags & InvocationMask) == 0)
{
// "Must specify binding flags describing the invoke operation required."
throw new ArgumentException(SR.Arg_NoAccessSpec, nameof(bindingFlags));
}
// Provide a default binding mask if none is provided
if ((bindingFlags & MemberBindingMask) == 0)
{
bindingFlags |= BindingFlags.Instance | BindingFlags.Public;
if ((bindingFlags & BindingFlags.CreateInstance) == 0)
{
bindingFlags |= BindingFlags.Static;
}
}
// There must not be more named parameters than provided arguments
if (namedParams != null)
{
if (providedArgs != null)
{
if (namedParams.Length > providedArgs.Length)
{
throw new ArgumentException(SR.Arg_NamedParamTooBig, nameof(namedParams));
}
}
else
{
if (namedParams.Length != 0)
{
throw new ArgumentException(SR.Arg_NamedParamTooBig, nameof(namedParams));
}
}
}
#if FEATURE_COMINTEROP
if (target != null && target.GetType().IsCOMObject)
{
const BindingFlags ClassicBindingMask =
BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.SetProperty |
BindingFlags.PutDispProperty | BindingFlags.PutRefDispProperty;
if ((bindingFlags & ClassicBindingMask) == 0)
{
throw new ArgumentException(SR.Arg_COMAccess, nameof(bindingFlags));
}
if ((bindingFlags & BindingFlags.GetProperty) != 0 && (bindingFlags & ClassicBindingMask & ~(BindingFlags.GetProperty | BindingFlags.InvokeMethod)) != 0)
{
throw new ArgumentException(SR.Arg_PropSetGet, nameof(bindingFlags));
}
if ((bindingFlags & BindingFlags.InvokeMethod) != 0 && (bindingFlags & ClassicBindingMask & ~(BindingFlags.GetProperty | BindingFlags.InvokeMethod)) != 0)
{
throw new ArgumentException(SR.Arg_PropSetInvoke, nameof(bindingFlags));
}
if ((bindingFlags & BindingFlags.SetProperty) != 0 && (bindingFlags & ClassicBindingMask & ~BindingFlags.SetProperty) != 0)
{
throw new ArgumentException(SR.Arg_COMPropSetPut, nameof(bindingFlags));
}
if ((bindingFlags & BindingFlags.PutDispProperty) != 0 && (bindingFlags & ClassicBindingMask & ~BindingFlags.PutDispProperty) != 0)
{
throw new ArgumentException(SR.Arg_COMPropSetPut, nameof(bindingFlags));
}
if ((bindingFlags & BindingFlags.PutRefDispProperty) != 0 && (bindingFlags & ClassicBindingMask & ~BindingFlags.PutRefDispProperty) != 0)
{
throw new ArgumentException(SR.Arg_COMPropSetPut, nameof(bindingFlags));
}
ArgumentNullException.ThrowIfNull(name);
bool[]? isByRef = modifiers?[0].IsByRefArray;
// pass LCID_ENGLISH_US if no explicit culture is specified to match the behavior of VB
int lcid = (culture == null ? 0x0409 : culture.LCID);
// If a request to not wrap exceptions was made, we will unwrap
// the TargetInvocationException since that is what will be thrown.
bool unwrapExceptions = (bindingFlags & BindingFlags.DoNotWrapExceptions) != 0;
try
{
return(InvokeDispMethod(name, bindingFlags, target, providedArgs, isByRef, lcid, namedParams));
}
catch (TargetInvocationException e) when(unwrapExceptions)
{
// For target invocation exceptions, we need to unwrap the inner exception and
// re-throw it.
throw e.InnerException !;
}
}
#endif // FEATURE_COMINTEROP
if (namedParams != null && Array.IndexOf(namedParams, null !) >= 0)
{
throw new ArgumentException(SR.Arg_NamedParamNull, nameof(namedParams));
}
int argCnt = (providedArgs != null) ? providedArgs.Length : 0;
binder ??= DefaultBinder;
// Delegate to Activator.CreateInstance
if ((bindingFlags & BindingFlags.CreateInstance) != 0)
{
if ((bindingFlags & BindingFlags.CreateInstance) != 0 && (bindingFlags & BinderNonCreateInstance) != 0)
{
// "Can not specify both CreateInstance and another access type."
throw new ArgumentException(SR.Arg_CreatInstAccess, nameof(bindingFlags));
}
return(Activator.CreateInstance(this, bindingFlags, binder, providedArgs, culture));
}
// PutDispProperty and\or PutRefDispProperty ==> SetProperty.
if ((bindingFlags & (BindingFlags.PutDispProperty | BindingFlags.PutRefDispProperty)) != 0)
{
bindingFlags |= BindingFlags.SetProperty;
}
if (name.Length == 0 || name.Equals("[DISPID=0]"))
{
// in InvokeMember we always pretend there is a default member if none is provided and we make it ToString
name = GetDefaultMemberName() ! ?? "ToString";
}
// GetField or SetField
bool IsGetField = (bindingFlags & BindingFlags.GetField) != 0;
bool IsSetField = (bindingFlags & BindingFlags.SetField) != 0;
if (IsGetField || IsSetField)
{
if (IsGetField)
{
if (IsSetField)
{
throw new ArgumentException(SR.Arg_FldSetGet, nameof(bindingFlags));
}
if ((bindingFlags & BindingFlags.SetProperty) != 0)
{
throw new ArgumentException(SR.Arg_FldGetPropSet, nameof(bindingFlags));
}
}
else
{
Debug.Assert(IsSetField);
ArgumentNullException.ThrowIfNull(providedArgs);
if ((bindingFlags & BindingFlags.GetProperty) != 0)
{
throw new ArgumentException(SR.Arg_FldSetPropGet, nameof(bindingFlags));
}
if ((bindingFlags & BindingFlags.InvokeMethod) != 0)
{
throw new ArgumentException(SR.Arg_FldSetInvoke, nameof(bindingFlags));
}
}
// Lookup Field
FieldInfo?selFld = null;
FieldInfo[]? flds = GetMember(name, MemberTypes.Field, bindingFlags) as FieldInfo[];
Debug.Assert(flds != null);
if (flds.Length == 1)
{
selFld = flds[0];
}
else if (flds.Length > 0)
{
selFld = binder.BindToField(bindingFlags, flds, IsGetField ? Empty.Value : providedArgs ![0] !, culture);
// Determines whether a String represents true or false.
//
public static bool Parse(string value)
{
ArgumentNullException.ThrowIfNull(value);
return(Parse(value.AsSpan()));
}
public static string Intern(string str)
{
ArgumentNullException.ThrowIfNull(str);
return(InternalIntern(str));
}
