As part of updating the config file with recently added rules, also turn on a few of them.
# IDE0049: Use language keywords instead of framework type names for type references
dotnet_diagnostic.IDE0049.severity = warning
-# IDE0050: Convert anonymous type to tuple
-dotnet_diagnostic.IDE0050.severity = suggestion
-
# IDE0051: Remove unused private members
dotnet_diagnostic.IDE0051.severity = suggestion
# IDE0161: Convert to file-scoped namespace
dotnet_diagnostic.IDE0161.severity = silent
+# IDE0170: Simplify property pattern
+dotnet_diagnostic.IDE0170.severity = warning
+
+# IDE0180: Use tuple swap
+dotnet_diagnostic.IDE0180.severity = suggestion
+
+# IDE0200: Remove unnecessary lambda expression
+dotnet_diagnostic.IDE0200.severity = warning
+
+# IDE0210: Use top-level statements
+dotnet_diagnostic.IDE0210.severity = silent
+
+# IDE0211: Use program main
+dotnet_diagnostic.IDE0211.severity = silent
+
+# IDE0220: foreach cast
+dotnet_diagnostic.IDE0220.severity = silent
+
+# IDE0230: Use UTF8 string literal
+dotnet_diagnostic.IDE0230.severity = suggestion
+
# IDE1005: Delegate invocation can be simplified.
dotnet_diagnostic.IDE1005.severity = warning
# IDE0049: Use language keywords instead of framework type names for type references
dotnet_diagnostic.IDE0049.severity = silent
-# IDE0050: Convert anonymous type to tuple
-dotnet_diagnostic.IDE0050.severity = silent
-
# IDE0051: Remove unused private members
dotnet_diagnostic.IDE0051.severity = silent
# IDE0161: Convert to file-scoped namespace
dotnet_diagnostic.IDE0161.severity = silent
+# IDE0170: Simplify property pattern
+dotnet_diagnostic.IDE0170.severity = silent
+
+# IDE0180: Use tuple swap
+dotnet_diagnostic.IDE0180.severity = silent
+
+# IDE0200: Remove unnecessary lambda expression
+dotnet_diagnostic.IDE0200.severity = silent
+
+# IDE0210: Use top-level statements
+dotnet_diagnostic.IDE0210.severity = silent
+
+# IDE0211: Use program main
+dotnet_diagnostic.IDE0211.severity = silent
+
+# IDE0220: foreach cast
+dotnet_diagnostic.IDE0220.severity = silent
+
+# IDE0230: Use UTF8 string literal
+dotnet_diagnostic.IDE0230.severity = silent
+
# IDE1005: Delegate invocation can be simplified.
dotnet_diagnostic.IDE1005.severity = silent
[RequiresDynamicCode("Marshalling code for the object might not be available")]
public static byte ReadByte(object ptr, int ofs)
{
- return ReadValueSlow(ptr, ofs, (IntPtr nativeHome, int offset) => ReadByte(nativeHome, offset));
+ return ReadValueSlow(ptr, ofs, ReadByte);
}
[EditorBrowsable(EditorBrowsableState.Never)]
[RequiresDynamicCode("Marshalling code for the object might not be available")]
public static short ReadInt16(object ptr, int ofs)
{
- return ReadValueSlow(ptr, ofs, (IntPtr nativeHome, int offset) => ReadInt16(nativeHome, offset));
+ return ReadValueSlow(ptr, ofs, ReadInt16);
}
[EditorBrowsable(EditorBrowsableState.Never)]
[RequiresDynamicCode("Marshalling code for the object might not be available")]
public static int ReadInt32(object ptr, int ofs)
{
- return ReadValueSlow(ptr, ofs, (IntPtr nativeHome, int offset) => ReadInt32(nativeHome, offset));
+ return ReadValueSlow(ptr, ofs, ReadInt32);
}
[EditorBrowsable(EditorBrowsableState.Never)]
public static long ReadInt64([MarshalAs(UnmanagedType.AsAny), In] object ptr, int ofs)
#pragma warning restore CS0618 // Type or member is obsolete
{
- return ReadValueSlow(ptr, ofs, (IntPtr nativeHome, int offset) => ReadInt64(nativeHome, offset));
+ return ReadValueSlow(ptr, ofs, ReadInt64);
}
/// <summary>Read value from marshaled object (marshaled using AsAny).</summary>
[RequiresDynamicCode("Marshalling code for the object might not be available")]
public static void WriteByte(object ptr, int ofs, byte val)
{
- WriteValueSlow(ptr, ofs, val, (IntPtr nativeHome, int offset, byte value) => WriteByte(nativeHome, offset, value));
+ WriteValueSlow(ptr, ofs, val, WriteByte);
}
[EditorBrowsable(EditorBrowsableState.Never)]
[RequiresDynamicCode("Marshalling code for the object might not be available")]
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));
+ WriteValueSlow(ptr, ofs, val, Marshal.WriteInt16);
}
[EditorBrowsable(EditorBrowsableState.Never)]
[RequiresDynamicCode("Marshalling code for the object might not be available")]
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));
+ WriteValueSlow(ptr, ofs, val, Marshal.WriteInt32);
}
[EditorBrowsable(EditorBrowsableState.Never)]
[RequiresDynamicCode("Marshalling code for the object might not be available")]
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));
+ WriteValueSlow(ptr, ofs, val, Marshal.WriteInt64);
}
/// <summary>
// wrong endianness here), DER encode it, then use the DER reader to skip past the tag
// and length.
byte[] derEncoded = OpenSslEncode(
- handle => GetAsn1IntegerDerSize(handle),
- (handle, buf) => EncodeAsn1Integer(handle, buf),
+ GetAsn1IntegerDerSize,
+ EncodeAsn1Integer,
asn1Integer);
try
internal static int ResolveRequiredNid(string oid)
{
- return s_nidLookup.GetOrAdd(oid, s => LookupNid(s));
+ return s_nidLookup.GetOrAdd(oid, LookupNid);
}
private static int LookupNid(string oid)
internal static byte[] GetAsn1StringBytes(IntPtr asn1)
{
- return GetDynamicBuffer((ptr, buf, i) => GetAsn1StringBytes(ptr, buf, i), asn1);
+ return GetDynamicBuffer(GetAsn1StringBytes, asn1);
}
internal static byte[] GetX509Thumbprint(SafeX509Handle x509)
{
- return GetDynamicBuffer((handle, buf, i) => GetX509Thumbprint(handle, buf, i), x509);
+ return GetDynamicBuffer(GetX509Thumbprint, x509);
}
internal static X500DistinguishedName LoadX500Name(IntPtr namePtr)
{
CheckValidOpenSslHandle(namePtr);
- byte[] buf = GetDynamicBuffer((ptr, buf1, i) => GetX509NameRawBytes(ptr, buf1, i), namePtr);
+ byte[] buf = GetDynamicBuffer(GetX509NameRawBytes, namePtr);
return new X500DistinguishedName(buf);
}
internal static byte[] GetX509PublicKeyParameterBytes(SafeX509Handle x509)
{
- return GetDynamicBuffer((handle, buf, i) => GetX509PublicKeyParameterBytes(handle, buf, i), x509);
+ return GetDynamicBuffer(GetX509PublicKeyParameterBytes, x509);
}
internal static void X509StoreSetVerifyTime(SafeX509StoreHandle ctx, DateTime verifyTime)
{
internal static ArraySegment<byte> RentAsn1StringBytes(IntPtr asn1)
{
- return RentDynamicBuffer((ptr, buf, i) => GetAsn1StringBytes(ptr, buf, i), asn1);
+ return RentDynamicBuffer(GetAsn1StringBytes, asn1);
}
private static ArraySegment<byte> RentDynamicBuffer<THandle>(NegativeSizeReadMethod<THandle> method, THandle handle)
CheckValidOpenSslHandle(x);
return SafeInteriorHandle.OpenInteriorHandle(
- handle => X509GetSerialNumber_private(handle),
+ X509GetSerialNumber_private,
x);
}
CheckValidOpenSslHandle(x);
return SafeInteriorHandle.OpenInteriorHandle(
- (handle, arg) => CryptoNative_X509FindExtensionData(handle, arg),
+ CryptoNative_X509FindExtensionData,
x,
extensionNid);
}
{
CheckValidOpenSslHandle(namePtr);
- byte[] buf = GetDynamicBuffer((ptr, buf1, i) => GetX509NameRawBytes(ptr, buf1, i), namePtr);
+ byte[] buf = GetDynamicBuffer(GetX509NameRawBytes, namePtr);
return new X500DistinguishedName(buf);
}
CheckValidOpenSslHandle(sk);
return SafeInteriorHandle.OpenInteriorHandle(
- (handle, i) => GetX509NameStackField_private(handle, i),
+ GetX509NameStackField_private,
sk,
loc);
}
internal static SafeSharedX509StackHandle X509StoreCtxGetSharedUntrusted(SafeX509StoreCtxHandle ctx)
{
return SafeInteriorHandle.OpenInteriorHandle(
- x => X509StoreCtxGetSharedUntrusted_private(x),
+ X509StoreCtxGetSharedUntrusted_private,
ctx);
}
}
hashAlgorithm,
secretPrepend,
secretAppend,
- (pubKey, hasher) => DeriveSecretAgreement(pubKey, hasher));
+ DeriveSecretAgreement);
}
public override byte[] DeriveKeyFromHmac(
hmacKey,
secretPrepend,
secretAppend,
- (pubKey, hasher) => DeriveSecretAgreement(pubKey, hasher));
+ DeriveSecretAgreement);
}
public override byte[] DeriveKeyTls(ECDiffieHellmanPublicKey otherPartyPublicKey, byte[] prfLabel, byte[] prfSeed)
otherPartyPublicKey,
prfLabel,
prfSeed,
- (pubKey, hasher) => DeriveSecretAgreement(pubKey, hasher));
+ DeriveSecretAgreement);
}
/// <summary>
hashAlgorithm,
secretPrepend,
secretAppend,
- (pubKey, hasher) => DeriveSecretAgreement(pubKey, hasher));
+ DeriveSecretAgreement);
}
public override byte[] DeriveKeyFromHmac(
hmacKey,
secretPrepend,
secretAppend,
- (pubKey, hasher) => DeriveSecretAgreement(pubKey, hasher));
+ DeriveSecretAgreement);
}
public override byte[] DeriveKeyTls(ECDiffieHellmanPublicKey otherPartyPublicKey, byte[] prfLabel, byte[] prfSeed)
otherPartyPublicKey,
prfLabel,
prfSeed,
- (pubKey, hasher) => DeriveSecretAgreement(pubKey, hasher));
+ DeriveSecretAgreement);
}
/// <summary>
hashAlgorithm,
secretPrepend,
secretAppend,
- (pubKey, hasher) => DeriveSecretAgreement(pubKey, hasher));
+ DeriveSecretAgreement);
}
public override byte[] DeriveKeyFromHmac(
hmacKey,
secretPrepend,
secretAppend,
- (pubKey, hasher) => DeriveSecretAgreement(pubKey, hasher));
+ DeriveSecretAgreement);
}
public override byte[] DeriveKeyTls(ECDiffieHellmanPublicKey otherPartyPublicKey, byte[] prfLabel, byte[] prfSeed)
otherPartyPublicKey,
prfLabel,
prfSeed,
- (pubKey, hasher) => DeriveSecretAgreement(pubKey, hasher));
+ DeriveSecretAgreement);
}
private byte[]? DeriveSecretAgreement(ECDiffieHellmanPublicKey otherPartyPublicKey, IncrementalHash? hasher)
IConfigurationProvider provider = source.Build(this);
provider.Load();
- _changeTokenRegistrations.Add(ChangeToken.OnChange(() => provider.GetReloadToken(), () => RaiseChanged()));
+ _changeTokenRegistrations.Add(ChangeToken.OnChange(provider.GetReloadToken, RaiseChanged));
_providerManager.AddProvider(provider);
RaiseChanged();
foreach (IConfigurationProvider p in newProvidersList)
{
p.Load();
- _changeTokenRegistrations.Add(ChangeToken.OnChange(() => p.GetReloadToken(), () => RaiseChanged()));
+ _changeTokenRegistrations.Add(ChangeToken.OnChange(p.GetReloadToken, RaiseChanged));
}
_providerManager.ReplaceProviders(newProvidersList);
foreach (IConfigurationProvider p in providers)
{
p.Load();
- _changeTokenRegistrations.Add(ChangeToken.OnChange(() => p.GetReloadToken(), () => RaiseChanged()));
+ _changeTokenRegistrations.Add(ChangeToken.OnChange(p.GetReloadToken, RaiseChanged));
}
}
{
if (!_stackGuard.TryEnterOnCurrentStack())
{
- return _stackGuard.RunOnEmptyStack((type, chain) => CreateCallSite(type, chain), serviceType, callSiteChain);
+ return _stackGuard.RunOnEmptyStack(CreateCallSite, serviceType, callSiteChain);
}
// We need to lock the resolution process for a single service type at a time:
{
if (!_stackGuard.TryEnterOnCurrentStack())
{
- return _stackGuard.RunOnEmptyStack((c, a) => VisitCallSite(c, a), callSite, argument);
+ return _stackGuard.RunOnEmptyStack(VisitCallSite, callSite, argument);
}
switch (callSite.Cache.Location)
}
_filters = filters;
- _fileWatcherFactory = () => CreateFileWatcher();
+ _fileWatcherFactory = CreateFileWatcher;
}
/// <summary>
{
Logger.LogInformation("Application is shutting down...");
});
- ApplicationLifetime.ApplicationStopped.Register(() =>
- {
- _delayStop.Set();
- });
+ ApplicationLifetime.ApplicationStopped.Register(_delayStop.Set);
Thread thread = new Thread(Run);
thread.IsBackground = true;
void RegisterSource(IOptionsChangeTokenSource<TOptions> source)
{
IDisposable registration = ChangeToken.OnChange(
- () => source.GetChangeToken(),
- (name) => InvokeChanged(name),
+ source.GetChangeToken,
+ InvokeChanged,
source.Name);
_registrations.Add(registration);
if (serviceProvider != null)
{
IServiceProvider localServiceProvider = serviceProvider;
- InitializeServiceProvider(serviceType => localServiceProvider.GetService(serviceType));
+ InitializeServiceProvider(localServiceProvider.GetService);
}
_items = items != null ? new Dictionary<object, object?>(items) : new Dictionary<object, object?>();
Requires.NotNullOrNullElements(attributedParts, nameof(attributedParts));
CompositionBatch batch = new CompositionBatch(
- attributedParts.Select(attributedPart => AttributedModelServices.CreatePart(attributedPart)).ToArray(),
+ attributedParts.Select(AttributedModelServices.CreatePart).ToArray(),
Enumerable.Empty<ComposablePart>());
container.Compose(batch);
{
traversal.Initialize();
var traversalClosure = GetTraversalClosure(_innerCatalog.Where(_filter), traversal);
- return new FilteredCatalog(_innerCatalog, p => traversalClosure.Contains(p));
+ return new FilteredCatalog(_innerCatalog, traversalClosure.Contains);
}
finally
{
if (disposable != null)
{
- disposeAction = () => disposable.Dispose();
+ disposeAction = disposable.Dispose;
}
else
{
}
Func<Export, object> exportFactoryFactory = (Func<Export, object>)Delegate.CreateDelegate(typeof(Func<Export, object>), this, genericMethod);
- return (e) => exportFactoryFactory.Invoke(e);
+ return exportFactoryFactory.Invoke;
}
private object CreateStronglyTypedExportFactoryOfT<T>(Export export)
_asyncOperation = AsyncOperationManager.CreateOperation(null);
Task.Factory.StartNew(
- arg => WorkerThreadStart(arg),
+ WorkerThreadStart,
argument,
CancellationToken.None,
TaskCreationOptions.DenyChildAttach,
/// <summary>
/// Constant value provided so that subclasses can avoid creating additional duplicate values.
/// </summary>
- protected static readonly Func<IEnumerable<CompositionDependency>> NoDependencies = () => Enumerable.Empty<CompositionDependency>();
+ protected static readonly Func<IEnumerable<CompositionDependency>> NoDependencies = Enumerable.Empty<CompositionDependency>;
/// <summary>
/// Promise export descriptors for the specified export key.
}
var name = closedGenericType.Name.Substring(0, closedGenericType.Name.IndexOf('`'));
- var args = closedGenericType.GenericTypeArguments.Select(t => Format(t));
+ var args = closedGenericType.GenericTypeArguments.Select(Format);
return $"{name}<{string.Join(", ", args)}>";
}
}
Debug.Assert(closedGenericType.IsConstructedGenericType);
var name = closedGenericType.Name.Substring(0, closedGenericType.Name.IndexOf('`'));
- IEnumerable<string> args = closedGenericType.GenericTypeArguments.Select(t => Format(t));
+ IEnumerable<string> args = closedGenericType.GenericTypeArguments.Select(Format);
return $"{name}<{string.Join(SR.Formatter_ListSeparatorWithSpace, args)}>";
}
}
}
// to support oracle types and other INUllable types that have static Null as field
- internal static object GetStaticNullForUdtType([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type type) => s_typeToNull.GetOrAdd(type, t => GetStaticNullForUdtTypeCore(t));
+ internal static object GetStaticNullForUdtType([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.PublicFields)] Type type) => s_typeToNull.GetOrAdd(type, GetStaticNullForUdtTypeCore);
[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2070:UnrecognizedReflectionPattern",
Justification = "The only callsite is marked with DynamicallyAccessedMembers. Workaround for https://github.com/mono/linker/issues/1981")]
private static IEnumerable<Type> GetPreviouslyDeclaredDataTypes(DataSet dataSet)
{
return (dataSet != null)
- ? dataSet.Tables.Cast<DataTable>().SelectMany(table => GetPreviouslyDeclaredDataTypes(table))
+ ? dataSet.Tables.Cast<DataTable>().SelectMany(GetPreviouslyDeclaredDataTypes)
: Enumerable.Empty<Type>();
}
{
if (instrument is not null && !_disposed && !instrument.Meter.Disposed)
{
- _enabledMeasurementInstruments.AddIfNotExist(instrument, (instrument1, instrument2) => object.ReferenceEquals(instrument1, instrument2));
+ _enabledMeasurementInstruments.AddIfNotExist(instrument, object.ReferenceEquals);
oldState = instrument.EnableMeasurement(new ListenerSubscription(this, state), out oldStateStored);
enabled = true;
}
object? state = null;
lock (Instrument.SyncObject)
{
- if (instrument is null || _enabledMeasurementInstruments.Remove(instrument, (instrument1, instrument2) => object.ReferenceEquals(instrument1, instrument2)) == default)
+ if (instrument is null || _enabledMeasurementInstruments.Remove(instrument, object.ReferenceEquals) == default)
{
return default;
}
source,
ruleSet,
tmpDest,
- (value, lastByte, dest) => CopyBitStringValue(value, lastByte, dest),
+ CopyBitStringValue,
isIndefinite,
out unusedBitCount,
out bytesRead);
private static readonly StringWithQualityHeaderValue s_gzipHeaderValue = new StringWithQualityHeaderValue("gzip");
private static readonly StringWithQualityHeaderValue s_deflateHeaderValue = new StringWithQualityHeaderValue("deflate");
- private static readonly Lazy<bool> s_supportsTls13 = new Lazy<bool>(() => CheckTls13Support());
+ private static readonly Lazy<bool> s_supportsTls13 = new Lazy<bool>(CheckTls13Support);
[ThreadStatic]
private static StringBuilder? t_requestHeadersBuilder;
public static IWebProxy? DefaultWebProxy
{
- get => LazyInitializer.EnsureInitialized<IWebProxy>(ref s_DefaultWebProxy, ref s_DefaultWebProxyInitialized, ref s_internalSyncObject, () => GetSystemWebProxy());
+ get => LazyInitializer.EnsureInitialized<IWebProxy>(ref s_DefaultWebProxy, ref s_DefaultWebProxyInitialized, ref s_internalSyncObject, GetSystemWebProxy);
set
{
lock (s_internalSyncObject)
IntPtr delegateTypeNative)
{
// Create a resolver callback for types.
- Func<AssemblyName, Assembly> resolver = name => alc.LoadFromAssemblyName(name);
+ Func<AssemblyName, Assembly> resolver = alc.LoadFromAssemblyName;
// Determine the signature of the type. There are 3 possibilities:
// * No delegate type was supplied - use the default (i.e. ComponentEntryPoint).
List<SessionInfo>? liveSessionList = null;
GetSessionInfo(
- (int etwSessionId, long matchAllKeywords, ref List<SessionInfo>? sessionList) =>
- GetSessionInfoCallback(etwSessionId, matchAllKeywords, ref sessionList),
+ GetSessionInfoCallback,
ref liveSessionList);
List<KeyValuePair<SessionInfo, bool>> changedSessionList = new List<KeyValuePair<SessionInfo, bool>>();
using SafeFileHandle src = SafeFileHandle.OpenReadOnly(sourceFullPath, FileOptions.None, out fileLength, out filePermissions);
using SafeFileHandle dst = SafeFileHandle.Open(destFullPath, overwrite ? FileMode.Create : FileMode.CreateNew,
FileAccess.ReadWrite, FileShare.None, FileOptions.None, preallocationSize: 0, filePermissions,
- (Interop.ErrorInfo error, Interop.Sys.OpenFlags flags, string path) => CreateOpenException(error, flags, path));
+ CreateOpenException);
Interop.CheckIo(Interop.Sys.CopyFile(src, dst, fileLength));
}
else
{
- return (obj) =>
- {
- return propInfo.GetValue(obj);
- };
+ return propInfo.GetValue;
}
}
else if (memberInfo is FieldInfo fieldInfo)
{
var xmlns = new XmlSerializerNamespaces();
p[index] = xmlns;
- member.XmlnsSource = (ns, name) => xmlns.Add(ns, name);
+ member.XmlnsSource = xmlns.Add;
}
member.Source = source;
{
anyMember.Collection = new CollectionMember();
anyMember.ArraySource = anyMember.Source;
- anyMember.Source = (item) =>
- {
- anyMember.Collection.Add(item);
- };
+ anyMember.Source = anyMember.Collection.Add;
anyAttribute = anyMember;
}
if (mapping.Attribute == null && mapping.Text == null)
{
anyMember.Collection = new CollectionMember();
- anyMember.ArraySource = (item) =>
- {
- anyMember.Collection.Add(item);
- };
+ anyMember.ArraySource = anyMember.Collection.Add;
textOrArrayMembersList.Add(anyMember);
}
&& !(mapping.Elements!.Length == 1 && mapping.Elements[0].Mapping is ArrayMapping))
{
anyMember.Collection = new CollectionMember();
- anyMember.ArraySource = (item) =>
- {
- anyMember.Collection.Add(item);
- };
+ anyMember.ArraySource = anyMember.Collection.Add;
membersList.Add(anyMember);
textOrArrayMembersList.Add(anyMember);
var arrayMember = new Member(memberMapping);
arrayMember.Collection = new CollectionMember();
- arrayMember.ArraySource = (item) =>
- {
- arrayMember.Collection.Add(item);
- };
+ arrayMember.ArraySource = arrayMember.Collection.Add;
if ((readOnly && o == null) || Reader.IsEmptyElement)
{
var xmlSerializerNamespaces = new XmlSerializerNamespaces();
var setMemberValue = GetSetMemberValueDelegate(o!, member.Mapping.Name);
setMemberValue(o, xmlSerializerNamespaces);
- member.XmlnsSource = (ns, name) =>
- {
- xmlSerializerNamespaces.Add(ns, name);
- };
+ member.XmlnsSource = xmlSerializerNamespaces.Add;
}
else
{
{
if (memberInfo is PropertyInfo propInfo)
{
- return delegate (object? o, object? p)
- {
- propInfo.SetValue(o, p);
- };
+ return propInfo.SetValue;
}
else if (memberInfo is FieldInfo fieldInfo)
{
- return delegate (object? o, object? p)
- {
- fieldInfo.SetValue(o, p);
- };
+ return fieldInfo.SetValue;
}
throw new InvalidOperationException(SR.XmlInternalError);
var setMethod = propInfo.GetSetMethod(true);
if (setMethod == null)
{
- return delegate (object? o, object? p)
- {
- // Maintain the same failure behavior as non-cached delegate
- propInfo.SetValue(o, p);
- };
+ return propInfo.SetValue;
}
setTypedDelegate = (Action<TObj, TParam>)setMethod.CreateDelegate(typeof(Action<TObj, TParam>));
MetadataLoadContext loader = defaultAssembly.Loader;
Func<AssemblyName, Assembly> assemblyResolver =
- delegate (AssemblyName assemblyName)
- {
- return loader.LoadFromAssemblyName(assemblyName);
- };
+ loader.LoadFromAssemblyName;
Func<Assembly?, string, bool, Type?> typeResolver =
delegate (Assembly? assembly, string fullName, bool ignoreCase2)
internal static SerializationEvents GetSerializationEventsForType(
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.All)] Type t) =>
- s_cache.GetOrAdd(t, type => CreateSerializationEvents(type));
+ s_cache.GetOrAdd(t, CreateSerializationEvents);
[UnconditionalSuppressMessage("ReflectionAnalysis", "IL2067:UnrecognizedReflectionPattern",
Justification = "The Type is annotated correctly, it just can't pass through the lambda method.")]
SignedAttributesSet signedAttrsSet = default;
signedAttrsSet.SignedAttributes = PkcsHelpers.NormalizeAttributeSet(
signedAttrs.ToArray(),
- normalized => hasher.AppendData(normalized));
+ hasher.AppendData);
// Since this contains user data in a context where BER is permitted, use BER.
// There shouldn't be any observable difference here between BER and DER, though,
return ExportArray(
passwordBytes,
pbeParameters,
- (ReadOnlySpan<byte> span, PbeParameters parameters, Span<byte> destination, out int i) =>
- TryExportEncryptedPkcs8PrivateKey(span, parameters, destination, out i));
+ TryExportEncryptedPkcs8PrivateKey);
}
public virtual byte[] ExportEncryptedPkcs8PrivateKey(
return ExportArray(
password,
pbeParameters,
- (ReadOnlySpan<char> span, PbeParameters parameters, Span<byte> destination, out int i) =>
- TryExportEncryptedPkcs8PrivateKey(span, parameters, destination, out i));
+ TryExportEncryptedPkcs8PrivateKey);
}
public virtual byte[] ExportPkcs8PrivateKey() =>
ExportArray(
- (Span<byte> destination, out int i) => TryExportPkcs8PrivateKey(destination, out i));
+ TryExportPkcs8PrivateKey);
public virtual byte[] ExportSubjectPublicKeyInfo() =>
ExportArray(
- (Span<byte> destination, out int i) => TryExportSubjectPublicKeyInfo(destination, out i));
+ TryExportSubjectPublicKeyInfo);
public virtual bool TryExportEncryptedPkcs8PrivateKey(
ReadOnlySpan<byte> passwordBytes,
/// </summary>
public static ECDsa? GetECDsaPublicKey(this X509Certificate2 certificate)
{
- return certificate.GetPublicKey<ECDsa>(cert => HasECDsaKeyUsage(cert));
+ return certificate.GetPublicKey<ECDsa>(HasECDsaKeyUsage);
}
/// <summary>
/// </summary>
public static ECDsa? GetECDsaPrivateKey(this X509Certificate2 certificate)
{
- return certificate.GetPrivateKey<ECDsa>(cert => HasECDsaKeyUsage(cert));
+ return certificate.GetPrivateKey<ECDsa>(HasECDsaKeyUsage);
}
public static X509Certificate2 CopyWithPrivateKey(this X509Certificate2 certificate, ECDsa privateKey)
{
Interop.Crypto.CheckValidOpenSslHandle(pkcs7);
return Interop.Crypto.OpenSslEncode(
- handle => Interop.Crypto.GetPkcs7DerSize(handle),
- (handle, buf) => Interop.Crypto.EncodePkcs7(handle, buf),
+ Interop.Crypto.GetPkcs7DerSize,
+ Interop.Crypto.EncodePkcs7,
pkcs7);
}
}
get
{
return Interop.Crypto.OpenSslEncode(
- x => Interop.Crypto.GetX509DerSize(x),
- (x, buf) => Interop.Crypto.EncodeX509(x, buf),
+ Interop.Crypto.GetX509DerSize,
+ Interop.Crypto.EncodeX509,
_cert);
}
}
using (SafeOcspRequestHandle req = Interop.Crypto.X509ChainBuildOcspRequest(_storeCtx, chainDepth))
{
ArraySegment<byte> encoded = Interop.Crypto.OpenSslRentEncode(
- handle => Interop.Crypto.GetOcspRequestDerSize(handle),
- (handle, buf) => Interop.Crypto.EncodeOcspRequest(handle, buf),
+ Interop.Crypto.GetOcspRequestDerSize,
+ Interop.Crypto.EncodeOcspRequest,
req);
ArraySegment<char> urlEncoded = UrlBase64Encoding.RentEncode(encoded);
{
return s_errorStrings.GetOrAdd(
code.Code,
- c => Interop.Crypto.GetX509VerifyCertErrorString(c));
+ Interop.Crypto.GetX509VerifyCertErrorString);
}
private sealed class WorkingChain : IDisposable
/// </exception>
public ECDiffieHellman? GetECDiffieHellmanPublicKey()
{
- return this.GetPublicKey<ECDiffieHellman>(cert => HasECDiffieHellmanKeyUsage(cert));
+ return this.GetPublicKey<ECDiffieHellman>(HasECDiffieHellmanKeyUsage);
}
/// <summary>
/// </exception>
public ECDiffieHellman? GetECDiffieHellmanPrivateKey()
{
- return this.GetPrivateKey<ECDiffieHellman>(cert => HasECDiffieHellmanKeyUsage(cert));
+ return this.GetPrivateKey<ECDiffieHellman>(HasECDiffieHellmanKeyUsage);
}
/// <summary>
{
SyndicationFeedFormatter.MoveToStartElement(reader);
SetDocument(AtomPub10ServiceDocumentFormatter.ReadCategories(reader, null,
- () => CreateInlineCategoriesDocument(),
- () => CreateReferencedCategoriesDocument(),
+ CreateInlineCategoriesDocument,
+ CreateReferencedCategoriesDocument,
Version,
_maxExtensionSize));
}
internal void DisposeEventNotify(EventNotify eventNotify)
{
- _proxy.Invoke2(delegate { eventNotify.Dispose(); });
+ _proxy.Invoke2(eventNotify.Dispose);
}
internal void SetGrammarOptions(SPGRAMMAROPTIONS options)
return typeGenerationSpec;
}
- internal static bool IsSyntaxTargetForGeneration(SyntaxNode node) => node is ClassDeclarationSyntax { AttributeLists: { Count: > 0 }, BaseList: { Types : {Count : > 0 } } };
+ internal static bool IsSyntaxTargetForGeneration(SyntaxNode node) => node is ClassDeclarationSyntax { AttributeLists.Count: > 0, BaseList.Types.Count: > 0 };
internal static ClassDeclarationSyntax? GetSemanticTargetForGeneration(GeneratorSyntaxContext context, CancellationToken cancellationToken)
{
{
int numChars = RegexCharClass.GetSetChars(childStart.Str!, setChars);
Debug.Assert(numChars != 0);
- writer.WriteLine($"case {string.Join(" or ", setChars.Slice(0, numChars).ToArray().Select(c => Literal(c)))}:");
+ writer.WriteLine($"case {string.Join(" or ", setChars.Slice(0, numChars).ToArray().Select(Literal))}:");
}
else
{
private static bool IsSyntaxTargetForGeneration(SyntaxNode node, CancellationToken cancellationToken) =>
// We don't have a semantic model here, so the best we can do is say whether there are any attributes.
- node is MethodDeclarationSyntax { AttributeLists: { Count: > 0 } };
+ node is MethodDeclarationSyntax { AttributeLists.Count: > 0 };
private static bool IsSemanticTargetForGeneration(SemanticModel semanticModel, MethodDeclarationSyntax methodDeclarationSyntax, CancellationToken cancellationToken)
{
onItemsRemoved, itemCountingFunc);
// Initialize target
- _target = new BatchBlockTargetCore(this, batchSize, batch => _source.AddMessage(batch), dataflowBlockOptions);
+ _target = new BatchBlockTargetCore(this, batchSize, _source.AddMessage, dataflowBlockOptions);
// When the target is done, let the source know it won't be getting any more data
_target.Completion.ContinueWith(delegate { _source.Complete(); },
public static bool IsSupported { get; } = ApplyUpdateEnabled(justComponentCheck: 0) != 0;
- private static Lazy<string> s_ApplyUpdateCapabilities = new Lazy<string>(() => InitializeApplyUpdateCapabilities());
+ private static readonly Lazy<string> s_ApplyUpdateCapabilities = new Lazy<string>(InitializeApplyUpdateCapabilities);
private static string InitializeApplyUpdateCapabilities()
{
if (request == null || store == null)
return false;
- return store.AllSources().FirstOrDefault(source => TryResolve(source)) != null;
+ return store.AllSources().FirstOrDefault(TryResolve) != null;
}
public bool CompareRequest(JObject req)
ParallelLoopResult result = Parallel.ForEach(
Partitioner.Create(argsList, EnumerablePartitionerOptions.NoBuffering),
new ParallelOptions { MaxDegreeOfParallelism = allowedParallelism },
- (args, state) => PrecompileLibraryParallel(args, state));
+ PrecompileLibraryParallel);
if (result.IsCompleted)
{
projects / platform / upstream / dotnet / runtime.git / commitdiff