// <auto-generated>
using System.Reflection;
namespace Microsoft.NetCore.Analyzers
{
internal static partial class MicrosoftNetCoreAnalyzersResources
{
private static global::System.Resources.ResourceManager s_resourceManager;
internal static global::System.Resources.ResourceManager ResourceManager => s_resourceManager ?? (s_resourceManager = new global::System.Resources.ResourceManager(typeof(MicrosoftNetCoreAnalyzersResources)));
internal static global::System.Globalization.CultureInfo Culture { get; set; }
#if !NET20
[global::System.Runtime.CompilerServices.MethodImpl(global::System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
#endif
internal static string GetResourceString(string resourceKey, string defaultValue = null) => ResourceManager.GetString(resourceKey, Culture);
/// <summary>SQL queries that directly use user input can be vulnerable to SQL injection attacks. Review this SQL query for potential vulnerabilities, and consider using a parameterized SQL query.</summary>
internal static string @ReviewSQLQueriesForSecurityVulnerabilitiesDescription => GetResourceString("ReviewSQLQueriesForSecurityVulnerabilitiesDescription");
/// <summary>Review if the query string passed to '{0}' in '{1}', accepts any user input</summary>
internal static string @ReviewSQLQueriesForSecurityVulnerabilitiesMessageNoNonLiterals => GetResourceString("ReviewSQLQueriesForSecurityVulnerabilitiesMessageNoNonLiterals");
/// <summary>Review SQL queries for security vulnerabilities</summary>
internal static string @ReviewSQLQueriesForSecurityVulnerabilitiesTitle => GetResourceString("ReviewSQLQueriesForSecurityVulnerabilitiesTitle");
/// <summary>Do not call ToImmutableCollection on an ImmutableCollection value</summary>
internal static string @DoNotCallToImmutableCollectionOnAnImmutableCollectionValueTitle => GetResourceString("DoNotCallToImmutableCollectionOnAnImmutableCollectionValueTitle");
/// <summary>Do not call {0} on an {1} value</summary>
internal static string @DoNotCallToImmutableCollectionOnAnImmutableCollectionValueMessage => GetResourceString("DoNotCallToImmutableCollectionOnAnImmutableCollectionValueMessage");
/// <summary>Remove redundant call</summary>
internal static string @RemoveRedundantCall => GetResourceString("RemoveRedundantCall");
/// <summary>P/Invokes should not be visible</summary>
internal static string @PInvokesShouldNotBeVisibleTitle => GetResourceString("PInvokesShouldNotBeVisibleTitle");
/// <summary>A public or protected method in a public type has the System.Runtime.InteropServices.DllImportAttribute attribute (also implemented by the Declare keyword in Visual Basic). Such methods should not be exposed.</summary>
internal static string @PInvokesShouldNotBeVisibleDescription => GetResourceString("PInvokesShouldNotBeVisibleDescription");
/// <summary>P/Invoke method '{0}' should not be visible</summary>
internal static string @PInvokesShouldNotBeVisibleMessage => GetResourceString("PInvokesShouldNotBeVisibleMessage");
/// <summary>Specify marshaling for P/Invoke string arguments</summary>
internal static string @SpecifyMarshalingForPInvokeStringArgumentsTitle => GetResourceString("SpecifyMarshalingForPInvokeStringArgumentsTitle");
/// <summary>A platform invoke member allows partially trusted callers, has a string parameter, and does not explicitly marshal the string. This can cause a potential security vulnerability.</summary>
internal static string @SpecifyMarshalingForPInvokeStringArgumentsDescription => GetResourceString("SpecifyMarshalingForPInvokeStringArgumentsDescription");
/// <summary>Use managed equivalents of win32 api</summary>
internal static string @UseManagedEquivalentsOfWin32ApiTitle => GetResourceString("UseManagedEquivalentsOfWin32ApiTitle");
/// <summary>An operating system invoke method is defined and a method that has the equivalent functionality is located in the .NET Framework class library.</summary>
internal static string @UseManagedEquivalentsOfWin32ApiDescription => GetResourceString("UseManagedEquivalentsOfWin32ApiDescription");
/// <summary>Use managed equivalents of win32 api</summary>
internal static string @UseManagedEquivalentsOfWin32ApiMessage => GetResourceString("UseManagedEquivalentsOfWin32ApiMessage");
/// <summary>Mark boolean PInvoke arguments with MarshalAs</summary>
internal static string @MarkBooleanPInvokeArgumentsWithMarshalAsTitle => GetResourceString("MarkBooleanPInvokeArgumentsWithMarshalAsTitle");
/// <summary>The Boolean data type has multiple representations in unmanaged code.</summary>
internal static string @MarkBooleanPInvokeArgumentsWithMarshalAsDescription => GetResourceString("MarkBooleanPInvokeArgumentsWithMarshalAsDescription");
/// <summary>Add the MarshalAsAttribute to parameter {0} of P/Invoke {1}. If the corresponding unmanaged parameter is a 4-byte Win32 'BOOL', use [MarshalAs(UnmanagedType.Bool)]. For a 1-byte C++ 'bool', use MarshalAs(UnmanagedType.U1).</summary>
internal static string @MarkBooleanPInvokeArgumentsWithMarshalAsMessageDefault => GetResourceString("MarkBooleanPInvokeArgumentsWithMarshalAsMessageDefault");
/// <summary>Add the MarshalAsAttribute to the return type of P/Invoke {0}. If the corresponding unmanaged return type is a 4-byte Win32 'BOOL', use MarshalAs(UnmanagedType.Bool). For a 1-byte C++ 'bool', use MarshalAs(UnmanagedType.U1).</summary>
internal static string @MarkBooleanPInvokeArgumentsWithMarshalAsMessageReturn => GetResourceString("MarkBooleanPInvokeArgumentsWithMarshalAsMessageReturn");
/// <summary>Mark assemblies with NeutralResourcesLanguageAttribute</summary>
internal static string @MarkAssembliesWithNeutralResourcesLanguageTitle => GetResourceString("MarkAssembliesWithNeutralResourcesLanguageTitle");
/// <summary>The NeutralResourcesLanguage attribute informs the ResourceManager of the language that was used to display the resources of a neutral culture for an assembly. This improves lookup performance for the first resource that you load and can reduce your workin ...</summary>
internal static string @MarkAssembliesWithNeutralResourcesLanguageDescription => GetResourceString("MarkAssembliesWithNeutralResourcesLanguageDescription");
/// <summary>Mark assemblies with NeutralResourcesLanguageAttribute</summary>
internal static string @MarkAssembliesWithNeutralResourcesLanguageMessage => GetResourceString("MarkAssembliesWithNeutralResourcesLanguageMessage");
/// <summary>Use ordinal string comparison</summary>
internal static string @UseOrdinalStringComparisonTitle => GetResourceString("UseOrdinalStringComparisonTitle");
/// <summary>A string comparison operation that is nonlinguistic does not set the StringComparison parameter to either Ordinal or OrdinalIgnoreCase. By explicitly setting the parameter to either StringComparison.Ordinal or StringComparison.OrdinalIgnoreCase, your code ...</summary>
internal static string @UseOrdinalStringComparisonDescription => GetResourceString("UseOrdinalStringComparisonDescription");
/// <summary>For non-empty collections, Count() and LongCount() enumerate the entire sequence, while Any() stops at the first item or the first item that satisfies a condition.</summary>
internal static string @DoNotUseCountWhenAnyCanBeUsedDescription => GetResourceString("DoNotUseCountWhenAnyCanBeUsedDescription");
/// <summary>{0}() is used where Any() could be used instead to improve performance</summary>
internal static string @DoNotUseCountWhenAnyCanBeUsedMessage => GetResourceString("DoNotUseCountWhenAnyCanBeUsedMessage");
/// <summary>Do not use Count() or LongCount() when Any() can be used</summary>
internal static string @DoNotUseCountWhenAnyCanBeUsedTitle => GetResourceString("DoNotUseCountWhenAnyCanBeUsedTitle");
/// <summary>Do not use 'AsParallel' in 'foreach'</summary>
internal static string @DoNotUseAsParallelInForEachLoopTitle => GetResourceString("DoNotUseAsParallelInForEachLoopTitle");
/// <summary>Using 'AsParallel()' directly in a 'foreach' loop has no effect and the loop is not parallelized</summary>
internal static string @DoNotUseAsParallelInForEachLoopMessage => GetResourceString("DoNotUseAsParallelInForEachLoopMessage");
/// <summary>Using 'AsParallel()' directly in a 'foreach' loop has no effect. The 'foreach' statement iterates serially through the collection regardless. To parallelize LINQ operations, call 'AsParallel()' earlier in the query chain before other LINQ operators. To par ...</summary>
internal static string @DoNotUseAsParallelInForEachLoopDescription => GetResourceString("DoNotUseAsParallelInForEachLoopDescription");
/// <summary>Prefer 'Convert.ToHexString' and 'Convert.ToHexStringLower' over call chains based on 'BitConverter.ToString'</summary>
internal static string @PreferConvertToHexStringOverBitConverterTitle => GetResourceString("PreferConvertToHexStringOverBitConverterTitle");
/// <summary>Use 'Convert.ToHexString' or 'Convert.ToHexStringLower' when encoding bytes to a hexadecimal string representation. These methods are more efficient and allocation-friendly than using 'BitConverter.ToString' in combination with 'String.Replace' to replace ...</summary>
internal static string @PreferConvertToHexStringOverBitConverterDescription => GetResourceString("PreferConvertToHexStringOverBitConverterDescription");
/// <summary>Prefer '{0}' over call chains based on '{1}'</summary>
internal static string @PreferConvertToHexStringOverBitConverterMessage => GetResourceString("PreferConvertToHexStringOverBitConverterMessage");
/// <summary>Replace with 'Convert.{0}'</summary>
internal static string @PreferConvertToHexStringOverBitConverterCodeFixTitle => GetResourceString("PreferConvertToHexStringOverBitConverterCodeFixTitle");
/// <summary>Do not use timers that prevent power state changes</summary>
internal static string @DoNotUseTimersThatPreventPowerStateChangesTitle => GetResourceString("DoNotUseTimersThatPreventPowerStateChangesTitle");
/// <summary>Higher-frequency periodic activity will keep the CPU busy and interfere with power-saving idle timers that turn off the display and hard disks.</summary>
internal static string @DoNotUseTimersThatPreventPowerStateChangesDescription => GetResourceString("DoNotUseTimersThatPreventPowerStateChangesDescription");
/// <summary>Do not use timers that prevent power state changes</summary>
internal static string @DoNotUseTimersThatPreventPowerStateChangesMessage => GetResourceString("DoNotUseTimersThatPreventPowerStateChangesMessage");
/// <summary>Avoid unsealed attributes</summary>
internal static string @AvoidUnsealedAttributesTitle => GetResourceString("AvoidUnsealedAttributesTitle");
/// <summary>The .NET Framework class library provides methods for retrieving custom attributes. By default, these methods search the attribute inheritance hierarchy. Sealing the attribute eliminates the search through the inheritance hierarchy and can improve performa ...</summary>
internal static string @AvoidUnsealedAttributesDescription => GetResourceString("AvoidUnsealedAttributesDescription");
/// <summary>Avoid unsealed attributes</summary>
internal static string @AvoidUnsealedAttributesMessage => GetResourceString("AvoidUnsealedAttributesMessage");
/// <summary>Avoid constant arrays as arguments</summary>
internal static string @AvoidConstArraysTitle => GetResourceString("AvoidConstArraysTitle");
/// <summary>Extract to static readonly field</summary>
internal static string @AvoidConstArraysCodeFixTitle => GetResourceString("AvoidConstArraysCodeFixTitle");
/// <summary>Constant arrays passed as arguments are not reused when called repeatedly, which implies a new array is created each time. Consider extracting them to 'static readonly' fields to improve performance if the passed array is not mutated within the called meth ...</summary>
internal static string @AvoidConstArraysDescription => GetResourceString("AvoidConstArraysDescription");
/// <summary>Prefer 'static readonly' fields over constant array arguments if the called method is called repeatedly and is not mutating the passed array</summary>
internal static string @AvoidConstArraysMessage => GetResourceString("AvoidConstArraysMessage");
/// <summary>Avoid inexact read with 'Stream.Read'</summary>
internal static string @AvoidUnreliableStreamReadTitle => GetResourceString("AvoidUnreliableStreamReadTitle");
/// <summary>Use 'Stream.ReadExactly'</summary>
internal static string @AvoidUnreliableStreamReadCodeFixTitle => GetResourceString("AvoidUnreliableStreamReadCodeFixTitle");
/// <summary>A call to 'Stream.Read' may return fewer bytes than requested, resulting in unreliable code if the return value is not checked.</summary>
internal static string @AvoidUnreliableStreamReadDescription => GetResourceString("AvoidUnreliableStreamReadDescription");
/// <summary>Avoid inexact read with '{0}'</summary>
internal static string @AvoidUnreliableStreamReadMessage => GetResourceString("AvoidUnreliableStreamReadMessage");
/// <summary>Test for empty strings using string length</summary>
internal static string @TestForEmptyStringsUsingStringLengthTitle => GetResourceString("TestForEmptyStringsUsingStringLengthTitle");
/// <summary>Comparing strings by using the String.Length property or the String.IsNullOrEmpty method is significantly faster than using Equals.</summary>
internal static string @TestForEmptyStringsUsingStringLengthDescription => GetResourceString("TestForEmptyStringsUsingStringLengthDescription");
/// <summary>Test for empty strings using 'string.Length' property or 'string.IsNullOrEmpty' method instead of an Equality check</summary>
internal static string @TestForEmptyStringsUsingStringLengthMessage => GetResourceString("TestForEmptyStringsUsingStringLengthMessage");
/// <summary>Do not lock on objects with weak identity</summary>
internal static string @DoNotLockOnObjectsWithWeakIdentityTitle => GetResourceString("DoNotLockOnObjectsWithWeakIdentityTitle");
/// <summary>An object is said to have a weak identity when it can be directly accessed across application domain boundaries. A thread that tries to acquire a lock on an object that has a weak identity can be blocked by a second thread in a different application domain ...</summary>
internal static string @DoNotLockOnObjectsWithWeakIdentityDescription => GetResourceString("DoNotLockOnObjectsWithWeakIdentityDescription");
/// <summary>Do not lock on objects with weak identity</summary>
internal static string @DoNotLockOnObjectsWithWeakIdentityMessage => GetResourceString("DoNotLockOnObjectsWithWeakIdentityMessage");
/// <summary>Do not raise reserved exception types</summary>
internal static string @DoNotRaiseReservedExceptionTypesTitle => GetResourceString("DoNotRaiseReservedExceptionTypesTitle");
/// <summary>An exception of type that is not sufficiently specific or reserved by the runtime should never be raised by user code. This makes the original error difficult to detect and debug. If this exception instance might be thrown, use a different exception type.</summary>
internal static string @DoNotRaiseReservedExceptionTypesDescription => GetResourceString("DoNotRaiseReservedExceptionTypesDescription");
/// <summary>Exception type {0} is not sufficiently specific</summary>
internal static string @DoNotRaiseReservedExceptionTypesMessageTooGeneric => GetResourceString("DoNotRaiseReservedExceptionTypesMessageTooGeneric");
/// <summary>Exception type {0} is reserved by the runtime</summary>
internal static string @DoNotRaiseReservedExceptionTypesMessageReserved => GetResourceString("DoNotRaiseReservedExceptionTypesMessageReserved");
/// <summary>Do not use 'StreamReader.EndOfStream' in async methods</summary>
internal static string @DoNotUseEndOfStreamInAsyncMethodsTitle => GetResourceString("DoNotUseEndOfStreamInAsyncMethodsTitle");
/// <summary>The property 'StreamReader.EndOfStream' can cause unintended synchronous blocking when no data is buffered. Instead, use 'StreamReader.ReadLineAsync' directly, which returns 'null' when reaching the end of the stream.</summary>
internal static string @DoNotUseEndOfStreamInAsyncMethodsDescription => GetResourceString("DoNotUseEndOfStreamInAsyncMethodsDescription");
/// <summary>Do not use '{0}' in an async method</summary>
internal static string @DoNotUseEndOfStreamInAsyncMethodsMessage => GetResourceString("DoNotUseEndOfStreamInAsyncMethodsMessage");
/// <summary>Initialize value type static fields inline</summary>
internal static string @InitializeValueTypeStaticFieldsInlineTitle => GetResourceString("InitializeValueTypeStaticFieldsInlineTitle");
/// <summary>Initialize reference type static fields inline</summary>
internal static string @InitializeReferenceTypeStaticFieldsInlineTitle => GetResourceString("InitializeReferenceTypeStaticFieldsInlineTitle");
/// <summary>A value type declares an explicit static constructor. To fix a violation of this rule, initialize all static data when it is declared and remove the static constructor.</summary>
internal static string @InitializeValueTypeStaticFieldsInlineDescription => GetResourceString("InitializeValueTypeStaticFieldsInlineDescription");
/// <summary>A reference type declares an explicit static constructor. To fix a violation of this rule, initialize all static data when it is declared and remove the static constructor.</summary>
internal static string @InitializeReferenceTypeStaticFieldsInlineDescription => GetResourceString("InitializeReferenceTypeStaticFieldsInlineDescription");
/// <summary>Initialize all static fields in '{0}' when those fields are declared and remove the explicit static constructor</summary>
internal static string @InitializeStaticFieldsInlineMessage => GetResourceString("InitializeStaticFieldsInlineMessage");
/// <summary>Disposable types should declare finalizer</summary>
internal static string @DisposableTypesShouldDeclareFinalizerTitle => GetResourceString("DisposableTypesShouldDeclareFinalizerTitle");
/// <summary>A type that implements System.IDisposable and has fields that suggest the use of unmanaged resources does not implement a finalizer, as described by Object.Finalize.</summary>
internal static string @DisposableTypesShouldDeclareFinalizerDescription => GetResourceString("DisposableTypesShouldDeclareFinalizerDescription");
/// <summary>Disposable types should declare finalizer</summary>
internal static string @DisposableTypesShouldDeclareFinalizerMessage => GetResourceString("DisposableTypesShouldDeclareFinalizerMessage");
/// <summary>Provide correct arguments to formatting methods</summary>
internal static string @ProvideCorrectArgumentsToFormattingMethodsTitle => GetResourceString("ProvideCorrectArgumentsToFormattingMethodsTitle");
/// <summary>The format argument that is passed to System.String.Format does not contain a format item that corresponds to each object argument, or vice versa.</summary>
internal static string @ProvideCorrectArgumentsToFormattingMethodsDescription => GetResourceString("ProvideCorrectArgumentsToFormattingMethodsDescription");
/// <summary>Provide correct arguments to formatting methods</summary>
internal static string @ProvideCorrectArgumentsToFormattingMethodsMessage => GetResourceString("ProvideCorrectArgumentsToFormattingMethodsMessage");
/// <summary>The format argument is not a valid format string</summary>
internal static string @ProvideCorrectArgumentsToFormattingMethodsInvalidFormatMessage => GetResourceString("ProvideCorrectArgumentsToFormattingMethodsInvalidFormatMessage");
/// <summary>Test for NaN correctly</summary>
internal static string @TestForNaNCorrectlyTitle => GetResourceString("TestForNaNCorrectlyTitle");
/// <summary>This expression tests a value against Single.Nan or Double.Nan. Use Single.IsNan(Single) or Double.IsNan(Double) to test the value.</summary>
internal static string @TestForNaNCorrectlyDescription => GetResourceString("TestForNaNCorrectlyDescription");
/// <summary>Test for NaN correctly</summary>
internal static string @TestForNaNCorrectlyMessage => GetResourceString("TestForNaNCorrectlyMessage");
/// <summary>Attribute string literals should parse correctly</summary>
internal static string @AttributeStringLiteralsShouldParseCorrectlyTitle => GetResourceString("AttributeStringLiteralsShouldParseCorrectlyTitle");
/// <summary>The string literal parameter of an attribute does not parse correctly for a URL, a GUID, or a version.</summary>
internal static string @AttributeStringLiteralsShouldParseCorrectlyDescription => GetResourceString("AttributeStringLiteralsShouldParseCorrectlyDescription");
/// <summary>In the constructor of '{0}', change the value of argument '{1}', which is currently "{2}", to something that can be correctly parsed as '{3}'</summary>
internal static string @AttributeStringLiteralsShouldParseCorrectlyMessageDefault => GetResourceString("AttributeStringLiteralsShouldParseCorrectlyMessageDefault");
/// <summary>In the constructor of '{0}', change the value of argument '{1}', which is currently an empty string (""), to something that can be correctly parsed as '{2}'</summary>
internal static string @AttributeStringLiteralsShouldParseCorrectlyMessageEmpty => GetResourceString("AttributeStringLiteralsShouldParseCorrectlyMessageEmpty");
/// <summary>Avoid zero-length array allocations</summary>
internal static string @AvoidZeroLengthArrayAllocationsTitle => GetResourceString("AvoidZeroLengthArrayAllocationsTitle");
/// <summary>Avoid unnecessary zero-length array allocations. Use {0} instead.</summary>
internal static string @AvoidZeroLengthArrayAllocationsMessage => GetResourceString("AvoidZeroLengthArrayAllocationsMessage");
/// <summary>Do not use Enumerable methods on indexable collections</summary>
internal static string @DoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyTitle => GetResourceString("DoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyTitle");
/// <summary>This collection is directly indexable. Going through LINQ here causes unnecessary allocations and CPU work.</summary>
internal static string @DoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyDescription => GetResourceString("DoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyDescription");
/// <summary>Do not use Enumerable methods on indexable collections. Instead use the collection directly.</summary>
internal static string @DoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyMessage => GetResourceString("DoNotUseEnumerableMethodsOnIndexableCollectionsInsteadUseTheCollectionDirectlyMessage");
/// <summary>Specify CultureInfo</summary>
internal static string @SpecifyCultureInfoTitle => GetResourceString("SpecifyCultureInfoTitle");
/// <summary>A method or constructor calls a member that has an overload that accepts a System.Globalization.CultureInfo parameter, and the method or constructor does not call the overload that takes the CultureInfo parameter. When a CultureInfo or System.IFormatProvid ...</summary>
internal static string @SpecifyCultureInfoDescription => GetResourceString("SpecifyCultureInfoDescription");
/// <summary>The behavior of '{0}' could vary based on the current user's locale settings. Replace this call in '{1}' with a call to '{2}'.</summary>
internal static string @SpecifyCultureInfoMessage => GetResourceString("SpecifyCultureInfoMessage");
/// <summary>Specify IFormatProvider</summary>
internal static string @SpecifyIFormatProviderTitle => GetResourceString("SpecifyIFormatProviderTitle");
/// <summary>A method or constructor calls one or more members that have overloads that accept a System.IFormatProvider parameter, and the method or constructor does not call the overload that takes the IFormatProvider parameter. When a System.Globalization.CultureInfo ...</summary>
internal static string @SpecifyIFormatProviderDescription => GetResourceString("SpecifyIFormatProviderDescription");
/// <summary>The behavior of '{0}' could vary based on the current user's locale settings. Replace this call in '{1}' with a call to '{2}'.</summary>
internal static string @SpecifyIFormatProviderMessageIFormatProviderAlternateString => GetResourceString("SpecifyIFormatProviderMessageIFormatProviderAlternateString");
/// <summary>The behavior of '{0}' could vary based on the current user's locale settings. Replace this call in '{1}' with a call to '{2}'.</summary>
internal static string @SpecifyIFormatProviderMessageIFormatProviderAlternate => GetResourceString("SpecifyIFormatProviderMessageIFormatProviderAlternate");
/// <summary>'{0}' passes '{1}' as the 'IFormatProvider' parameter to '{2}'. This property returns a culture that is inappropriate for formatting methods.</summary>
internal static string @SpecifyIFormatProviderMessageUICultureString => GetResourceString("SpecifyIFormatProviderMessageUICultureString");
/// <summary>'{0}' passes '{1}' as the 'IFormatProvider' parameter to '{2}'. This property returns a culture that is inappropriate for formatting methods.</summary>
internal static string @SpecifyIFormatProviderMessageUICulture => GetResourceString("SpecifyIFormatProviderMessageUICulture");
/// <summary>Specify StringComparison for clarity</summary>
internal static string @SpecifyStringComparisonCA1307Title => GetResourceString("SpecifyStringComparisonCA1307Title");
/// <summary>A string comparison operation uses a method overload that does not set a StringComparison parameter. It is recommended to use the overload with StringComparison parameter for clarity of intent. If the result will be displayed to the user, such as when sort ...</summary>
internal static string @SpecifyStringComparisonCA1307Description => GetResourceString("SpecifyStringComparisonCA1307Description");
/// <summary>'{0}' has a method overload that takes a 'StringComparison' parameter. Replace this call in '{1}' with a call to '{2}' for clarity of intent.</summary>
internal static string @SpecifyStringComparisonCA1307Message => GetResourceString("SpecifyStringComparisonCA1307Message");
/// <summary>Specify StringComparison for correctness</summary>
internal static string @SpecifyStringComparisonCA1310Title => GetResourceString("SpecifyStringComparisonCA1310Title");
/// <summary>A string comparison operation uses a method overload that does not set a StringComparison parameter, hence its behavior could vary based on the current user's locale settings. It is strongly recommended to use the overload with StringComparison parameter f ...</summary>
internal static string @SpecifyStringComparisonCA1310Description => GetResourceString("SpecifyStringComparisonCA1310Description");
/// <summary>The behavior of '{0}' could vary based on the current user's locale settings. Replace this call in '{1}' with a call to '{2}'.</summary>
internal static string @SpecifyStringComparisonCA1310Message => GetResourceString("SpecifyStringComparisonCA1310Message");
/// <summary>Normalize strings to uppercase</summary>
internal static string @NormalizeStringsToUppercaseTitle => GetResourceString("NormalizeStringsToUppercaseTitle");
/// <summary>Strings should be normalized to uppercase. A small group of characters cannot make a round trip when they are converted to lowercase. To make a round trip means to convert the characters from one locale to another locale that represents character data diff ...</summary>
internal static string @NormalizeStringsToUppercaseDescription => GetResourceString("NormalizeStringsToUppercaseDescription");
/// <summary>In method '{0}', replace the call to '{1}' with '{2}'</summary>
internal static string @NormalizeStringsToUppercaseMessageToUpper => GetResourceString("NormalizeStringsToUppercaseMessageToUpper");
/// <summary>Dispose methods should call SuppressFinalize</summary>
internal static string @CallGCSuppressFinalizeCorrectlyTitle => GetResourceString("CallGCSuppressFinalizeCorrectlyTitle");
/// <summary>A method that is an implementation of Dispose does not call GC.SuppressFinalize; or a method that is not an implementation of Dispose calls GC.SuppressFinalize; or a method calls GC.SuppressFinalize and passes something other than this (Me in Visual Basic) ...</summary>
internal static string @CallGCSuppressFinalizeCorrectlyDescription => GetResourceString("CallGCSuppressFinalizeCorrectlyDescription");
/// <summary>Change {0} to call {1}. This will prevent unnecessary finalization of the object once it has been disposed and it has fallen out of scope.</summary>
internal static string @CallGCSuppressFinalizeCorrectlyMessageNotCalledWithFinalizer => GetResourceString("CallGCSuppressFinalizeCorrectlyMessageNotCalledWithFinalizer");
/// <summary>Change {0} to call {1}. This will prevent derived types that introduce a finalizer from needing to re-implement 'IDisposable' to call it.</summary>
internal static string @CallGCSuppressFinalizeCorrectlyMessageNotCalled => GetResourceString("CallGCSuppressFinalizeCorrectlyMessageNotCalled");
/// <summary>{0} calls {1} on something other than itself. Change the call site to pass 'this' ('Me' in Visual Basic) instead.</summary>
internal static string @CallGCSuppressFinalizeCorrectlyMessageNotPassedThis => GetResourceString("CallGCSuppressFinalizeCorrectlyMessageNotPassedThis");
/// <summary>{0} calls {1}, a method that is typically only called within an implementation of 'IDisposable.Dispose'. Refer to the IDisposable pattern for more information.</summary>
internal static string @CallGCSuppressFinalizeCorrectlyMessageOutsideDispose => GetResourceString("CallGCSuppressFinalizeCorrectlyMessageOutsideDispose");
/// <summary>Instantiate argument exceptions correctly</summary>
internal static string @InstantiateArgumentExceptionsCorrectlyTitle => GetResourceString("InstantiateArgumentExceptionsCorrectlyTitle");
/// <summary>A call is made to the default (parameterless) constructor of an exception type that is or derives from ArgumentException, or an incorrect string argument is passed to a parameterized constructor of an exception type that is or derives from ArgumentExceptio ...</summary>
internal static string @InstantiateArgumentExceptionsCorrectlyDescription => GetResourceString("InstantiateArgumentExceptionsCorrectlyDescription");
/// <summary>Call the {0} constructor that contains a message and/or paramName parameter</summary>
internal static string @InstantiateArgumentExceptionsCorrectlyMessageNoArguments => GetResourceString("InstantiateArgumentExceptionsCorrectlyMessageNoArguments");
/// <summary>Method {0} passes parameter name '{1}' as the {2} argument to a {3} constructor. Replace this argument with a descriptive message and pass the parameter name in the correct position.</summary>
internal static string @InstantiateArgumentExceptionsCorrectlyMessageIncorrectMessage => GetResourceString("InstantiateArgumentExceptionsCorrectlyMessageIncorrectMessage");
/// <summary>Method {0} passes '{1}' as the {2} argument to a {3} constructor. Replace this argument with one of the method's parameter names. Note that the provided parameter name should have the exact casing as declared on the method.</summary>
internal static string @InstantiateArgumentExceptionsCorrectlyMessageIncorrectParameterName => GetResourceString("InstantiateArgumentExceptionsCorrectlyMessageIncorrectParameterName");
/// <summary>Use Array.Empty</summary>
internal static string @UseArrayEmpty => GetResourceString("UseArrayEmpty");
/// <summary>Use indexer</summary>
internal static string @UseIndexer => GetResourceString("UseIndexer");
/// <summary>A type that implements System.IDisposable declares fields that are of types that also implement IDisposable. The Dispose method of the field is not called by the Dispose method of the declaring type. To fix a violation of this rule, call Dispose on fields ...</summary>
internal static string @DisposableFieldsShouldBeDisposedDescription => GetResourceString("DisposableFieldsShouldBeDisposedDescription");
/// <summary>'{0}' contains field '{1}' that is of IDisposable type '{2}', but it is never disposed. Change the Dispose method on '{0}' to call Close or Dispose on this field.</summary>
internal static string @DisposableFieldsShouldBeDisposedMessage => GetResourceString("DisposableFieldsShouldBeDisposedMessage");
/// <summary>Disposable fields should be disposed</summary>
internal static string @DisposableFieldsShouldBeDisposedTitle => GetResourceString("DisposableFieldsShouldBeDisposedTitle");
/// <summary>A type that implements System.IDisposable inherits from a type that also implements IDisposable. The Dispose method of the inheriting type does not call the Dispose method of the parent type. To fix a violation of this rule, call base.Dispose in your Dispo ...</summary>
internal static string @DisposeMethodsShouldCallBaseClassDisposeDescription => GetResourceString("DisposeMethodsShouldCallBaseClassDisposeDescription");
/// <summary>Ensure that method '{0}' calls '{1}' in all possible control flow paths</summary>
internal static string @DisposeMethodsShouldCallBaseClassDisposeMessage => GetResourceString("DisposeMethodsShouldCallBaseClassDisposeMessage");
/// <summary>Dispose methods should call base class dispose</summary>
internal static string @DisposeMethodsShouldCallBaseClassDisposeTitle => GetResourceString("DisposeMethodsShouldCallBaseClassDisposeTitle");
/// <summary>If a disposable object is not explicitly disposed before all references to it are out of scope, the object will be disposed at some indeterminate time when the garbage collector runs the finalizer of the object. Because an exceptional event might occur tha ...</summary>
internal static string @DisposeObjectsBeforeLosingScopeDescription => GetResourceString("DisposeObjectsBeforeLosingScopeDescription");
/// <summary>Call System.IDisposable.Dispose on object created by '{0}' before all references to it are out of scope</summary>
internal static string @DisposeObjectsBeforeLosingScopeNotDisposedMessage => GetResourceString("DisposeObjectsBeforeLosingScopeNotDisposedMessage");
/// <summary>Use recommended dispose pattern to ensure that object created by '{0}' is disposed on all paths. If possible, wrap the creation within a 'using' statement or a 'using' declaration. Otherwise, use a try-finally pattern, with a dedicated local variable decla ...</summary>
internal static string @DisposeObjectsBeforeLosingScopeMayBeDisposedMessage => GetResourceString("DisposeObjectsBeforeLosingScopeMayBeDisposedMessage");
/// <summary>Object created by '{0}' is not disposed along all exception paths. Call System.IDisposable.Dispose on the object before all references to it are out of scope.</summary>
internal static string @DisposeObjectsBeforeLosingScopeNotDisposedOnExceptionPathsMessage => GetResourceString("DisposeObjectsBeforeLosingScopeNotDisposedOnExceptionPathsMessage");
/// <summary>Use recommended dispose pattern to ensure that object created by '{0}' is disposed on all exception paths. If possible, wrap the creation within a 'using' statement or a 'using' declaration. Otherwise, use a try-finally pattern, with a dedicated local vari ...</summary>
internal static string @DisposeObjectsBeforeLosingScopeMayBeDisposedOnExceptionPathsMessage => GetResourceString("DisposeObjectsBeforeLosingScopeMayBeDisposedOnExceptionPathsMessage");
/// <summary>Dispose objects before losing scope</summary>
internal static string @DisposeObjectsBeforeLosingScopeTitle => GetResourceString("DisposeObjectsBeforeLosingScopeTitle");
/// <summary>A method passes a string literal as a parameter to a constructor or method in the .NET Framework class library and that string should be localizable. To fix a violation of this rule, replace the string literal with a string retrieved through an instance of ...</summary>
internal static string @DoNotPassLiteralsAsLocalizedParametersDescription => GetResourceString("DoNotPassLiteralsAsLocalizedParametersDescription");
/// <summary>Method '{0}' passes a literal string as parameter '{1}' of a call to '{2}'. Retrieve the following string(s) from a resource table instead: "{3}".</summary>
internal static string @DoNotPassLiteralsAsLocalizedParametersMessage => GetResourceString("DoNotPassLiteralsAsLocalizedParametersMessage");
/// <summary>Do not pass literals as localized parameters</summary>
internal static string @DoNotPassLiteralsAsLocalizedParametersTitle => GetResourceString("DoNotPassLiteralsAsLocalizedParametersTitle");
/// <summary>Add the 'NonSerialized' attribute to this field.</summary>
internal static string @AddNonSerializedAttributeCodeActionTitle => GetResourceString("AddNonSerializedAttributeCodeActionTitle");
/// <summary>Add Serializable attribute</summary>
internal static string @AddSerializableAttributeCodeActionTitle => GetResourceString("AddSerializableAttributeCodeActionTitle");
/// <summary>An instance field of a type that is not serializable is declared in a type that is serializable.</summary>
internal static string @MarkAllNonSerializableFieldsDescription => GetResourceString("MarkAllNonSerializableFieldsDescription");
/// <summary>Field {0} is a member of type {1} which is serializable but is of type {2} which is not serializable</summary>
internal static string @MarkAllNonSerializableFieldsMessage => GetResourceString("MarkAllNonSerializableFieldsMessage");
/// <summary>Mark all non-serializable fields</summary>
internal static string @MarkAllNonSerializableFieldsTitle => GetResourceString("MarkAllNonSerializableFieldsTitle");
/// <summary>To be recognized by the common language runtime as serializable, types must be marked by using the SerializableAttribute attribute even when the type uses a custom serialization routine through implementation of the ISerializable interface.</summary>
internal static string @MarkISerializableTypesWithSerializableDescription => GetResourceString("MarkISerializableTypesWithSerializableDescription");
/// <summary>Add [Serializable] to {0} as this type implements ISerializable</summary>
internal static string @MarkISerializableTypesWithSerializableMessage => GetResourceString("MarkISerializableTypesWithSerializableMessage");
/// <summary>Mark ISerializable types with serializable</summary>
internal static string @MarkISerializableTypesWithSerializableTitle => GetResourceString("MarkISerializableTypesWithSerializableTitle");
/// <summary>Potential SQL injection vulnerability was found where '{0}' in method '{1}' may be tainted by user-controlled data from '{2}' in method '{3}'.</summary>
internal static string @ReviewCodeForSqlInjectionVulnerabilitiesMessage => GetResourceString("ReviewCodeForSqlInjectionVulnerabilitiesMessage");
/// <summary>Review code for SQL injection vulnerabilities</summary>
internal static string @ReviewCodeForSqlInjectionVulnerabilitiesTitle => GetResourceString("ReviewCodeForSqlInjectionVulnerabilitiesTitle");
/// <summary>The method '{0}' is insecure when deserializing untrusted data without a SerializationBinder to restrict the type of objects in the deserialized object graph.</summary>
internal static string @BinaryFormatterDeserializeMaybeWithoutBinderSetMessage => GetResourceString("BinaryFormatterDeserializeMaybeWithoutBinderSetMessage");
/// <summary>Ensure BinaryFormatter.Binder is set before calling BinaryFormatter.Deserialize</summary>
internal static string @BinaryFormatterDeserializeMaybeWithoutBinderSetTitle => GetResourceString("BinaryFormatterDeserializeMaybeWithoutBinderSetTitle");
/// <summary>The method '{0}' is insecure when deserializing untrusted data without a SerializationBinder to restrict the type of objects in the deserialized object graph.</summary>
internal static string @BinaryFormatterDeserializeWithoutBinderSetMessage => GetResourceString("BinaryFormatterDeserializeWithoutBinderSetMessage");
/// <summary>Do not call BinaryFormatter.Deserialize without first setting BinaryFormatter.Binder</summary>
internal static string @BinaryFormatterDeserializeWithoutBinderSetTitle => GetResourceString("BinaryFormatterDeserializeWithoutBinderSetTitle");
/// <summary>The method '{0}' is insecure when deserializing untrusted data. If you need to instead detect BinaryFormatter deserialization without a SerializationBinder set, then disable rule CA2300, and enable rules CA2301 and CA2302.</summary>
internal static string @BinaryFormatterMethodUsedDescription => GetResourceString("BinaryFormatterMethodUsedDescription");
/// <summary>The method '{0}' is insecure when deserializing untrusted data.</summary>
internal static string @BinaryFormatterMethodUsedMessage => GetResourceString("BinaryFormatterMethodUsedMessage");
/// <summary>Do not use insecure deserializer BinaryFormatter</summary>
internal static string @BinaryFormatterMethodUsedTitle => GetResourceString("BinaryFormatterMethodUsedTitle");
/// <summary>The method '{0}' is insecure when deserializing untrusted data.</summary>
internal static string @LosFormatterMethodUsedMessage => GetResourceString("LosFormatterMethodUsedMessage");
/// <summary>Do not use insecure deserializer LosFormatter</summary>
internal static string @LosFormatterMethodUsedTitle => GetResourceString("LosFormatterMethodUsedTitle");
/// <summary>Potential DLL injection vulnerability was found where '{0}' in method '{1}' may be tainted by user-controlled data from '{2}' in method '{3}'.</summary>
internal static string @ReviewCodeForDllInjectionVulnerabilitiesMessage => GetResourceString("ReviewCodeForDllInjectionVulnerabilitiesMessage");
/// <summary>Review code for DLL injection vulnerabilities</summary>
internal static string @ReviewCodeForDllInjectionVulnerabilitiesTitle => GetResourceString("ReviewCodeForDllInjectionVulnerabilitiesTitle");
/// <summary>Potential information disclosure vulnerability was found where '{0}' in method '{1}' may contain unintended information from '{2}' in method '{3}'.</summary>
internal static string @ReviewCodeForInformationDisclosureVulnerabilitiesMessage => GetResourceString("ReviewCodeForInformationDisclosureVulnerabilitiesMessage");
/// <summary>Review code for information disclosure vulnerabilities</summary>
internal static string @ReviewCodeForInformationDisclosureVulnerabilitiesTitle => GetResourceString("ReviewCodeForInformationDisclosureVulnerabilitiesTitle");
/// <summary>Potential file path injection vulnerability was found where '{0}' in method '{1}' may be tainted by user-controlled data from '{2}' in method '{3}'.</summary>
internal static string @ReviewCodeForFilePathInjectionVulnerabilitiesMessage => GetResourceString("ReviewCodeForFilePathInjectionVulnerabilitiesMessage");
/// <summary>Review code for file path injection vulnerabilities</summary>
internal static string @ReviewCodeForFilePathInjectionVulnerabilitiesTitle => GetResourceString("ReviewCodeForFilePathInjectionVulnerabilitiesTitle");
/// <summary>Potential process command injection vulnerability was found where '{0}' in method '{1}' may be tainted by user-controlled data from '{2}' in method '{3}'.</summary>
internal static string @ReviewCodeForProcessCommandInjectionVulnerabilitiesMessage => GetResourceString("ReviewCodeForProcessCommandInjectionVulnerabilitiesMessage");
/// <summary>Review code for process command injection vulnerabilities</summary>
internal static string @ReviewCodeForProcessCommandInjectionVulnerabilitiesTitle => GetResourceString("ReviewCodeForProcessCommandInjectionVulnerabilitiesTitle");
/// <summary>Potential regex injection vulnerability was found where '{0}' in method '{1}' may be tainted by user-controlled data from '{2}' in method '{3}'.</summary>
internal static string @ReviewCodeForRegexInjectionVulnerabilitiesMessage => GetResourceString("ReviewCodeForRegexInjectionVulnerabilitiesMessage");
/// <summary>Review code for regex injection vulnerabilities</summary>
internal static string @ReviewCodeForRegexInjectionVulnerabilitiesTitle => GetResourceString("ReviewCodeForRegexInjectionVulnerabilitiesTitle");
/// <summary>The method '{0}' is insecure when deserializing untrusted data without a SerializationBinder to restrict the type of objects in the deserialized object graph.</summary>
internal static string @NetDataContractSerializerDeserializeMaybeWithoutBinderSetMessage => GetResourceString("NetDataContractSerializerDeserializeMaybeWithoutBinderSetMessage");
/// <summary>Ensure NetDataContractSerializer.Binder is set before deserializing</summary>
internal static string @NetDataContractSerializerDeserializeMaybeWithoutBinderSetTitle => GetResourceString("NetDataContractSerializerDeserializeMaybeWithoutBinderSetTitle");
/// <summary>The method '{0}' is insecure when deserializing untrusted data without a SerializationBinder to restrict the type of objects in the deserialized object graph.</summary>
internal static string @NetDataContractSerializerDeserializeWithoutBinderSetMessage => GetResourceString("NetDataContractSerializerDeserializeWithoutBinderSetMessage");
/// <summary>Do not deserialize without first setting NetDataContractSerializer.Binder</summary>
internal static string @NetDataContractSerializerDeserializeWithoutBinderSetTitle => GetResourceString("NetDataContractSerializerDeserializeWithoutBinderSetTitle");
/// <summary>The method '{0}' is insecure when deserializing untrusted data. If you need to instead detect NetDataContractSerializer deserialization without a SerializationBinder set, then disable rule CA2310, and enable rules CA2311 and CA2312.</summary>
internal static string @NetDataContractSerializerMethodUsedDescription => GetResourceString("NetDataContractSerializerMethodUsedDescription");
/// <summary>The method '{0}' is insecure when deserializing untrusted data.</summary>
internal static string @NetDataContractSerializerMethodUsedMessage => GetResourceString("NetDataContractSerializerMethodUsedMessage");
/// <summary>Do not use insecure deserializer NetDataContractSerializer</summary>
internal static string @NetDataContractSerializerMethodUsedTitle => GetResourceString("NetDataContractSerializerMethodUsedTitle");
/// <summary>The method '{0}' is insecure when deserializing untrusted data.</summary>
internal static string @ObjectStateFormatterMethodUsedMessage => GetResourceString("ObjectStateFormatterMethodUsedMessage");
/// <summary>Do not use insecure deserializer ObjectStateFormatter</summary>
internal static string @ObjectStateFormatterMethodUsedTitle => GetResourceString("ObjectStateFormatterMethodUsedTitle");
/// <summary>Potential cross-site scripting (XSS) vulnerability was found where '{0}' in method '{1}' may be tainted by user-controlled data from '{2}' in method '{3}'.</summary>
internal static string @ReviewCodeForXssVulnerabilitiesMessage => GetResourceString("ReviewCodeForXssVulnerabilitiesMessage");
/// <summary>Review code for XSS vulnerabilities</summary>
internal static string @ReviewCodeForXssVulnerabilitiesTitle => GetResourceString("ReviewCodeForXssVulnerabilitiesTitle");
/// <summary>Potential LDAP injection vulnerability was found where '{0}' in method '{1}' may be tainted by user-controlled data from '{2}' in method '{3}'.</summary>
internal static string @ReviewCodeForLdapInjectionVulnerabilitiesMessage => GetResourceString("ReviewCodeForLdapInjectionVulnerabilitiesMessage");
/// <summary>Review code for LDAP injection vulnerabilities</summary>
internal static string @ReviewCodeForLdapInjectionVulnerabilitiesTitle => GetResourceString("ReviewCodeForLdapInjectionVulnerabilitiesTitle");
/// <summary>The method '{0}' is insecure when deserializing untrusted data with a JavaScriptSerializer initialized with a SimpleTypeResolver. Ensure that the JavaScriptSerializer is initialized without a JavaScriptTypeResolver specified, or initialized with a JavaScri ...</summary>
internal static string @JavaScriptSerializerMaybeWithSimpleTypeResolverMessage => GetResourceString("JavaScriptSerializerMaybeWithSimpleTypeResolverMessage");
/// <summary>Ensure JavaScriptSerializer is not initialized with SimpleTypeResolver before deserializing</summary>
internal static string @JavaScriptSerializerMaybeWithSimpleTypeResolverTitle => GetResourceString("JavaScriptSerializerMaybeWithSimpleTypeResolverTitle");
/// <summary>The method '{0}' is insecure when deserializing untrusted data with a JavaScriptSerializer initialized with a SimpleTypeResolver. Initialize JavaScriptSerializer without a JavaScriptTypeResolver specified, or initialize with a JavaScriptTypeResolver that l ...</summary>
internal static string @JavaScriptSerializerWithSimpleTypeResolverMessage => GetResourceString("JavaScriptSerializerWithSimpleTypeResolverMessage");
/// <summary>Do not deserialize with JavaScriptSerializer using a SimpleTypeResolver</summary>
internal static string @JavaScriptSerializerWithSimpleTypeResolverTitle => GetResourceString("JavaScriptSerializerWithSimpleTypeResolverTitle");
/// <summary>Potential open redirect vulnerability was found where '{0}' in method '{1}' may be tainted by user-controlled data from '{2}' in method '{3}'.</summary>
internal static string @ReviewCodeForOpenRedirectVulnerabilitiesMessage => GetResourceString("ReviewCodeForOpenRedirectVulnerabilitiesMessage");
/// <summary>Review code for open redirect vulnerabilities</summary>
internal static string @ReviewCodeForOpenRedirectVulnerabilitiesTitle => GetResourceString("ReviewCodeForOpenRedirectVulnerabilitiesTitle");
/// <summary>Potential XPath injection vulnerability was found where '{0}' in method '{1}' may be tainted by user-controlled data from '{2}' in method '{3}'.</summary>
internal static string @ReviewCodeForXPathInjectionVulnerabilitiesMessage => GetResourceString("ReviewCodeForXPathInjectionVulnerabilitiesMessage");
/// <summary>Review code for XPath injection vulnerabilities</summary>
internal static string @ReviewCodeForXPathInjectionVulnerabilitiesTitle => GetResourceString("ReviewCodeForXPathInjectionVulnerabilitiesTitle");
/// <summary>Potential XML injection vulnerability was found where '{0}' in method '{1}' may be tainted by user-controlled data from '{2}' in method '{3}'.</summary>
internal static string @ReviewCodeForXmlInjectionVulnerabilitiesMessage => GetResourceString("ReviewCodeForXmlInjectionVulnerabilitiesMessage");
/// <summary>Review code for XML injection vulnerabilities</summary>
internal static string @ReviewCodeForXmlInjectionVulnerabilitiesTitle => GetResourceString("ReviewCodeForXmlInjectionVulnerabilitiesTitle");
/// <summary>Potential XAML injection vulnerability was found where '{0}' in method '{1}' may be tainted by user-controlled data from '{2}' in method '{3}'.</summary>
internal static string @ReviewCodeForXamlInjectionVulnerabilitiesMessage => GetResourceString("ReviewCodeForXamlInjectionVulnerabilitiesMessage");
/// <summary>Review code for XAML injection vulnerabilities</summary>
internal static string @ReviewCodeForXamlInjectionVulnerabilitiesTitle => GetResourceString("ReviewCodeForXamlInjectionVulnerabilitiesTitle");
/// <summary>When deserializing untrusted input, allowing arbitrary types to be deserialized is insecure. When using JsonSerializerSettings, use TypeNameHandling.None, or for values other than None, restrict deserialized types with a SerializationBinder.</summary>
internal static string @JsonNetInsecureSettingsMessage => GetResourceString("JsonNetInsecureSettingsMessage");
/// <summary>Do not use insecure JsonSerializerSettings</summary>
internal static string @JsonNetInsecureSettingsTitle => GetResourceString("JsonNetInsecureSettingsTitle");
/// <summary>When deserializing untrusted input, allowing arbitrary types to be deserialized is insecure. When using JsonSerializerSettings, ensure TypeNameHandling.None is specified, or for values other than None, ensure a SerializationBinder is specified to restrict ...</summary>
internal static string @JsonNetMaybeInsecureSettingsMessage => GetResourceString("JsonNetMaybeInsecureSettingsMessage");
/// <summary>Ensure that JsonSerializerSettings are secure</summary>
internal static string @JsonNetMaybeInsecureSettingsTitle => GetResourceString("JsonNetMaybeInsecureSettingsTitle");
/// <summary>Do not set Switch.System.ServiceModel.DisableUsingServicePointManagerSecurityProtocols to true. Setting this switch limits Windows Communication Framework (WCF) to using Transport Layer Security (TLS) 1.0, which is insecure and obsolete.</summary>
internal static string @DoNotDisableUsingServicePointManagerSecurityProtocolsMessage => GetResourceString("DoNotDisableUsingServicePointManagerSecurityProtocolsMessage");
/// <summary>Do not disable ServicePointManagerSecurityProtocols</summary>
internal static string @DoNotDisableUsingServicePointManagerSecurityProtocolsTitle => GetResourceString("DoNotDisableUsingServicePointManagerSecurityProtocolsTitle");
/// <summary>Deserializing JSON when using a TypeNameHandling value other than None can be insecure. If you need to instead detect Json.NET deserialization when a SerializationBinder isn't specified, then disable rule CA2326, and enable rules CA2327, CA2328, CA2329, a ...</summary>
internal static string @JsonNetTypeNameHandlingDescription => GetResourceString("JsonNetTypeNameHandlingDescription");
/// <summary>Deserializing JSON when using a TypeNameHandling value other than None can be insecure.</summary>
internal static string @JsonNetTypeNameHandlingMessage => GetResourceString("JsonNetTypeNameHandlingMessage");
/// <summary>Do not use TypeNameHandling values other than None</summary>
internal static string @JsonNetTypeNameHandlingTitle => GetResourceString("JsonNetTypeNameHandlingTitle");
/// <summary>Review cipher mode usage with cryptography experts</summary>
internal static string @ApprovedCipherMode => GetResourceString("ApprovedCipherMode");
/// <summary>These cipher modes might be vulnerable to attacks. Consider using recommended modes (CBC, CTS).</summary>
internal static string @ApprovedCipherModeDescription => GetResourceString("ApprovedCipherModeDescription");
/// <summary>Review the usage of cipher mode '{0}' with cryptography experts. Consider using recommended modes (CBC, CTS).</summary>
internal static string @ApprovedCipherModeMessage => GetResourceString("ApprovedCipherModeMessage");
/// <summary>Do Not Add Certificates To Root Store</summary>
internal static string @DefinitelyInstallRootCert => GetResourceString("DefinitelyInstallRootCert");
/// <summary>Adding certificates to the operating system's trusted root certificates increases the risk of incorrectly authenticating an illegitimate certificate</summary>
internal static string @DefinitelyInstallRootCertMessage => GetResourceString("DefinitelyInstallRootCertMessage");
/// <summary>Use Secure Cookies In ASP.NET Core</summary>
internal static string @DefinitelyUseSecureCookiesASPNetCore => GetResourceString("DefinitelyUseSecureCookiesASPNetCore");
/// <summary>Set CookieOptions.Secure = true when setting a cookie</summary>
internal static string @DefinitelyUseSecureCookiesASPNetCoreMessage => GetResourceString("DefinitelyUseSecureCookiesASPNetCoreMessage");
/// <summary>Do Not Add Schema By URL</summary>
internal static string @DoNotAddSchemaByURL => GetResourceString("DoNotAddSchemaByURL");
/// <summary>This overload of XmlSchemaCollection.Add method internally enables DTD processing on the XML reader instance used, and uses UrlResolver for resolving external XML entities. The outcome is information disclosure. Content from file system or network shares f ...</summary>
internal static string @DoNotAddSchemaByURLDescription => GetResourceString("DoNotAddSchemaByURLDescription");
/// <summary>This overload of the Add method is potentially unsafe because it may resolve dangerous external references</summary>
internal static string @DoNotAddSchemaByURLMessage => GetResourceString("DoNotAddSchemaByURLMessage");
/// <summary>Do Not Call Dangerous Methods In Deserialization</summary>
internal static string @DoNotCallDangerousMethodsInDeserializationTitle => GetResourceString("DoNotCallDangerousMethodsInDeserializationTitle");
/// <summary>Insecure Deserialization is a vulnerability which occurs when untrusted data is used to abuse the logic of an application, inflict a Denial-of-Service (DoS) attack, or even execute arbitrary code upon it being deserialized. It’s frequently possible for mal ...</summary>
internal static string @DoNotCallDangerousMethodsInDeserializationDescription => GetResourceString("DoNotCallDangerousMethodsInDeserializationDescription");
/// <summary>When deserializing an instance of class '{0}', method '{1}' can directly or indirectly call dangerous method '{2}'</summary>
internal static string @DoNotCallDangerousMethodsInDeserializationMessage => GetResourceString("DoNotCallDangerousMethodsInDeserializationMessage");
/// <summary>Do Not Disable Certificate Validation</summary>
internal static string @DoNotDisableCertificateValidation => GetResourceString("DoNotDisableCertificateValidation");
/// <summary>A certificate can help authenticate the identity of the server. Clients should validate the server certificate to ensure requests are sent to the intended server. If the ServerCertificateValidationCallback always returns 'true', any certificate will pass v ...</summary>
internal static string @DoNotDisableCertificateValidationDescription => GetResourceString("DoNotDisableCertificateValidationDescription");
/// <summary>The ServerCertificateValidationCallback is set to a function that accepts any server certificate, by always returning true. Ensure that server certificates are validated to verify the identity of the server receiving requests.</summary>
internal static string @DoNotDisableCertificateValidationMessage => GetResourceString("DoNotDisableCertificateValidationMessage");
/// <summary>Do Not Disable HTTP Header Checking</summary>
internal static string @DoNotDisableHTTPHeaderChecking => GetResourceString("DoNotDisableHTTPHeaderChecking");
/// <summary>HTTP header checking enables encoding of the carriage return and newline characters, \r and \n, that are found in response headers. This encoding can help to avoid injection attacks that exploit an application that echoes untrusted data contained by the he ...</summary>
internal static string @DoNotDisableHTTPHeaderCheckingDescription => GetResourceString("DoNotDisableHTTPHeaderCheckingDescription");
/// <summary>Do not disable HTTP header checking</summary>
internal static string @DoNotDisableHTTPHeaderCheckingMessage => GetResourceString("DoNotDisableHTTPHeaderCheckingMessage");
/// <summary>Do Not Disable Request Validation</summary>
internal static string @DoNotDisableRequestValidation => GetResourceString("DoNotDisableRequestValidation");
/// <summary>Request validation is a feature in ASP.NET that examines HTTP requests and determines whether they contain potentially dangerous content. This check adds protection from markup or code in the URL query string, cookies, or posted form values that might have ...</summary>
internal static string @DoNotDisableRequestValidationDescription => GetResourceString("DoNotDisableRequestValidationDescription");
/// <summary>{0} has request validation disabled</summary>
internal static string @DoNotDisableRequestValidationMessage => GetResourceString("DoNotDisableRequestValidationMessage");
/// <summary>Do Not Disable SChannel Use of Strong Crypto</summary>
internal static string @DoNotDisableSchUseStrongCrypto => GetResourceString("DoNotDisableSchUseStrongCrypto");
/// <summary>Starting with the .NET Framework 4.6, the System.Net.ServicePointManager and System.Net.Security.SslStream classes are recommended to use new protocols. The old ones have protocol weaknesses and are not supported. Setting Switch.System.Net.DontEnableSchUse ...</summary>
internal static string @DoNotDisableSchUseStrongCryptoDescription => GetResourceString("DoNotDisableSchUseStrongCryptoDescription");
/// <summary>{0} disables TLS 1.2 and enables SSLv3</summary>
internal static string @DoNotDisableSchUseStrongCryptoMessage => GetResourceString("DoNotDisableSchUseStrongCryptoMessage");
/// <summary>Do not hard-code encryption key</summary>
internal static string @DoNotHardCodeEncryptionKey => GetResourceString("DoNotHardCodeEncryptionKey");
/// <summary>SymmetricAlgorithm's .Key property, or a method's rgbKey parameter, should never be a hard-coded value.</summary>
internal static string @DoNotHardCodeEncryptionKeyDescription => GetResourceString("DoNotHardCodeEncryptionKeyDescription");
/// <summary>Potential security vulnerability was found where '{0}' in method '{1}' may be tainted by hard-coded key from '{2}' in method '{3}'</summary>
internal static string @DoNotHardCodeEncryptionKeyMessage => GetResourceString("DoNotHardCodeEncryptionKeyMessage");
/// <summary>By default, the Trusted Root Certification Authorities certificate store is configured with a set of public CAs that has met the requirements of the Microsoft Root Certificate Program. Since all trusted root CAs can issue certificates for any domain, an at ...</summary>
internal static string @DoNotInstallRootCertDescription => GetResourceString("DoNotInstallRootCertDescription");
/// <summary>Potential reference cycle in deserialized object graph</summary>
internal static string @PotentialReferenceCycleInDeserializedObjectGraphTitle => GetResourceString("PotentialReferenceCycleInDeserializedObjectGraphTitle");
/// <summary>Review code that processes untrusted deserialized data for handling of unexpected reference cycles. An unexpected reference cycle should not cause the code to enter an infinite loop. Otherwise, an unexpected reference cycle can allow an attacker to DOS or ...</summary>
internal static string @PotentialReferenceCycleInDeserializedObjectGraphDescription => GetResourceString("PotentialReferenceCycleInDeserializedObjectGraphDescription");
/// <summary>{0} participates in a potential reference cycle</summary>
internal static string @PotentialReferenceCycleInDeserializedObjectGraphMessage => GetResourceString("PotentialReferenceCycleInDeserializedObjectGraphMessage");
/// <summary>Do Not Serialize Types With Pointer Fields</summary>
internal static string @DoNotSerializeTypesWithPointerFields => GetResourceString("DoNotSerializeTypesWithPointerFields");
/// <summary>Pointers are not "type safe" in the sense that you cannot guarantee the correctness of the memory they point at. So, serializing types with pointer fields is dangerous, as it may allow an attacker to control the pointer.</summary>
internal static string @DoNotSerializeTypesWithPointerFieldsDescription => GetResourceString("DoNotSerializeTypesWithPointerFieldsDescription");
/// <summary>Pointer field {0} on serializable type</summary>
internal static string @DoNotSerializeTypesWithPointerFieldsMessage => GetResourceString("DoNotSerializeTypesWithPointerFieldsMessage");
/// <summary>Do Not Use Account Shared Access Signature</summary>
internal static string @DoNotUseAccountSAS => GetResourceString("DoNotUseAccountSAS");
/// <summary>Shared Access Signatures(SAS) are a vital part of the security model for any application using Azure Storage, they should provide limited and safe permissions to your storage account to clients that don't have the account key. All of the operations availab ...</summary>
internal static string @DoNotUseAccountSASDescription => GetResourceString("DoNotUseAccountSASDescription");
/// <summary>Use Service SAS instead of Account SAS for fine grained access control and container-level access policy</summary>
internal static string @DoNotUseAccountSASMessage => GetResourceString("DoNotUseAccountSASMessage");
/// <summary>Do Not Use Broken Cryptographic Algorithms</summary>
internal static string @DoNotUseBrokenCryptographicAlgorithms => GetResourceString("DoNotUseBrokenCryptographicAlgorithms");
/// <summary>An attack making it computationally feasible to break this algorithm exists. This allows attackers to break the cryptographic guarantees it is designed to provide. Depending on the type and application of this cryptographic algorithm, this may allow attack ...</summary>
internal static string @DoNotUseBrokenCryptographicAlgorithmsDescription => GetResourceString("DoNotUseBrokenCryptographicAlgorithmsDescription");
/// <summary>{0} uses a broken cryptographic algorithm {1}</summary>
internal static string @DoNotUseBrokenCryptographicAlgorithmsMessage => GetResourceString("DoNotUseBrokenCryptographicAlgorithmsMessage");
/// <summary>Do Not Use Deprecated Security Protocols</summary>
internal static string @DoNotUseDeprecatedSecurityProtocols => GetResourceString("DoNotUseDeprecatedSecurityProtocols");
/// <summary>Using a deprecated security protocol rather than the system default is risky.</summary>
internal static string @DoNotUseDeprecatedSecurityProtocolsDescription => GetResourceString("DoNotUseDeprecatedSecurityProtocolsDescription");
/// <summary>Hard-coded use of deprecated security protocol {0}</summary>
internal static string @DoNotUseDeprecatedSecurityProtocolsMessage => GetResourceString("DoNotUseDeprecatedSecurityProtocolsMessage");
/// <summary>Do Not Use Digital Signature Algorithm (DSA)</summary>
internal static string @DoNotUseDSA => GetResourceString("DoNotUseDSA");
/// <summary>DSA is too weak to use.</summary>
internal static string @DoNotUseDSADescription => GetResourceString("DoNotUseDSADescription");
/// <summary>Asymmetric encryption algorithm {0} is weak. Switch to an RSA with at least 2048 key size, ECDH or ECDSA algorithm instead.</summary>
internal static string @DoNotUseDSAMessage => GetResourceString("DoNotUseDSAMessage");
/// <summary>Do not use obsolete key derivation function</summary>
internal static string @DoNotUseObsoleteKDFAlgorithm => GetResourceString("DoNotUseObsoleteKDFAlgorithm");
/// <summary>Password-based key derivation should use PBKDF2 with SHA-2. Avoid using PasswordDeriveBytes since it generates a PBKDF1 key. Avoid using Rfc2898DeriveBytes.CryptDeriveKey since it doesn't use the iteration count or salt.</summary>
internal static string @DoNotUseObsoleteKDFAlgorithmDescription => GetResourceString("DoNotUseObsoleteKDFAlgorithmDescription");
/// <summary>Call to obsolete key derivation function {0}.{1}</summary>
internal static string @DoNotUseObsoleteKDFAlgorithmMessage => GetResourceString("DoNotUseObsoleteKDFAlgorithmMessage");
/// <summary>Value type typed arguments are uniquely boxed for each call to this method, therefore the result can be unexpected.</summary>
internal static string @DoNotUseReferenceEqualsWithValueTypesDescription => GetResourceString("DoNotUseReferenceEqualsWithValueTypesDescription");
/// <summary>Do not pass an argument with value type '{0}' to the 'Equals' method on 'ReferenceEqualityComparer'. Due to value boxing, this call to 'Equals' can return an unexpected result. Consider using 'EqualityComparer' instead, or pass reference type arguments if ...</summary>
internal static string @DoNotUseReferenceEqualsWithValueTypesComparerMessage => GetResourceString("DoNotUseReferenceEqualsWithValueTypesComparerMessage");
/// <summary>Do not pass an argument with value type '{0}' to 'ReferenceEquals'. Due to value boxing, this call to 'ReferenceEquals' can return an unexpected result. Consider using 'Equals' instead, or pass reference type arguments if you intend to use 'ReferenceEquals ...</summary>
internal static string @DoNotUseReferenceEqualsWithValueTypesMethodMessage => GetResourceString("DoNotUseReferenceEqualsWithValueTypesMethodMessage");
/// <summary>Do not use ReferenceEquals with value types</summary>
internal static string @DoNotUseReferenceEqualsWithValueTypesTitle => GetResourceString("DoNotUseReferenceEqualsWithValueTypesTitle");
/// <summary>Do Not Use Weak Cryptographic Algorithms</summary>
internal static string @DoNotUseWeakCryptographicAlgorithms => GetResourceString("DoNotUseWeakCryptographicAlgorithms");
/// <summary>Cryptographic algorithms degrade over time as attacks become for advances to attacker get access to more computation. Depending on the type and application of this cryptographic algorithm, further degradation of the cryptographic strength of it may allow a ...</summary>
internal static string @DoNotUseWeakCryptographicAlgorithmsDescription => GetResourceString("DoNotUseWeakCryptographicAlgorithmsDescription");
/// <summary>{0} uses a weak cryptographic algorithm {1}</summary>
internal static string @DoNotUseWeakCryptographicAlgorithmsMessage => GetResourceString("DoNotUseWeakCryptographicAlgorithmsMessage");
/// <summary>Ensure Key Derivation Function algorithm is sufficiently strong</summary>
internal static string @DoNotUseWeakKDFAlgorithm => GetResourceString("DoNotUseWeakKDFAlgorithm");
/// <summary>Some implementations of the Rfc2898DeriveBytes class allow for a hash algorithm to be specified in a constructor parameter or overwritten in the HashAlgorithm property. If a hash algorithm is specified, then it should be SHA-256 or higher.</summary>
internal static string @DoNotUseWeakKDFAlgorithmDescription => GetResourceString("DoNotUseWeakKDFAlgorithmDescription");
/// <summary>{0} might be using a weak hash algorithm. Use SHA256, SHA384, or SHA512 to create a strong key from a password.</summary>
internal static string @DoNotUseWeakKDFAlgorithmMessage => GetResourceString("DoNotUseWeakKDFAlgorithmMessage");
/// <summary>Do Not Use XslTransform</summary>
internal static string @DoNotUseXslTransform => GetResourceString("DoNotUseXslTransform");
/// <summary>Do not use XslTransform. It does not restrict potentially dangerous external references.</summary>
internal static string @DoNotUseXslTransformMessage => GetResourceString("DoNotUseXslTransformMessage");
/// <summary>Avoid hardcoding SecurityProtocolType {0}, and instead use SecurityProtocolType.SystemDefault to allow the operating system to choose the best Transport Layer Security protocol to use.</summary>
internal static string @HardCodedSecurityProtocolMessage => GetResourceString("HardCodedSecurityProtocolMessage");
/// <summary>Avoid hardcoding SecurityProtocolType value</summary>
internal static string @HardCodedSecurityProtocolTitle => GetResourceString("HardCodedSecurityProtocolTitle");
/// <summary>Ensure Certificates Are Not Added To Root Store</summary>
internal static string @MaybeInstallRootCert => GetResourceString("MaybeInstallRootCert");
/// <summary>Adding certificates to the operating system's trusted root certificates is insecure. Ensure that the target store is not root store.</summary>
internal static string @MaybeInstallRootCertMessage => GetResourceString("MaybeInstallRootCertMessage");
/// <summary>Ensure Use Secure Cookies In ASP.NET Core</summary>
internal static string @MaybeUseSecureCookiesASPNetCore => GetResourceString("MaybeUseSecureCookiesASPNetCore");
/// <summary>Ensure that CookieOptions.Secure = true when setting a cookie</summary>
internal static string @MaybeUseSecureCookiesASPNetCoreMessage => GetResourceString("MaybeUseSecureCookiesASPNetCoreMessage");
/// <summary>Set ViewStateUserKey For Classes Derived From Page</summary>
internal static string @SetViewStateUserKey => GetResourceString("SetViewStateUserKey");
/// <summary>Setting the ViewStateUserKey property can help you prevent attacks on your application by allowing you to assign an identifier to the view-state variable for individual users so that they cannot use the variable to generate an attack. Otherwise, there will ...</summary>
internal static string @SetViewStateUserKeyDescription => GetResourceString("SetViewStateUserKeyDescription");
/// <summary>The class {0} derived from System.Web.UI.Page does not set the ViewStateUserKey property in the OnInit method or Page_Init method</summary>
internal static string @SetViewStateUserKeyMessage => GetResourceString("SetViewStateUserKeyMessage");
/// <summary>The Range-based indexer on array values produces a copy of requested portion of the array. This copy is often unwanted when it is implicitly used as a Span or Memory value. Use the AsSpan method to avoid the copy.</summary>
internal static string @UseAsSpanInsteadOfArrayRangeIndexerDescription => GetResourceString("UseAsSpanInsteadOfArrayRangeIndexerDescription");
/// <summary>The Range-based indexer on string values produces a copy of requested portion of the string. This copy is usually unnecessary when it is implicitly used as a ReadOnlySpan or ReadOnlyMemory value. Use the AsSpan method to avoid the unnecessary copy.</summary>
internal static string @UseAsSpanInsteadOfStringRangeIndexerDescription => GetResourceString("UseAsSpanInsteadOfStringRangeIndexerDescription");
/// <summary>Use '{0}' instead of the '{1}'-based indexer on '{2}' to avoid creating unnecessary data copies</summary>
internal static string @UseAsSpanInsteadOfRangeIndexerMessage => GetResourceString("UseAsSpanInsteadOfRangeIndexerMessage");
/// <summary>Use AsSpan or AsMemory instead of Range-based indexers when appropriate</summary>
internal static string @UseAsSpanInsteadOfRangeIndexerTitle => GetResourceString("UseAsSpanInsteadOfRangeIndexerTitle");
/// <summary>The Range-based indexer on array values produces a copy of requested portion of the array. This copy is usually unnecessary when it is implicitly used as a ReadOnlySpan or ReadOnlyMemory value. Use the AsSpan method to avoid the unnecessary copy.</summary>
internal static string @UseAsSpanReadOnlyInsteadOfArrayRangeIndexerDescription => GetResourceString("UseAsSpanReadOnlyInsteadOfArrayRangeIndexerDescription");
/// <summary>Use Container Level Access Policy</summary>
internal static string @UseContainerLevelAccessPolicy => GetResourceString("UseContainerLevelAccessPolicy");
/// <summary>No access policy identifier is specified, making tokens non-revocable.</summary>
internal static string @UseContainerLevelAccessPolicyDescription => GetResourceString("UseContainerLevelAccessPolicyDescription");
/// <summary>Consider using Azure's role-based access control instead of a Shared Access Signature (SAS) if possible. If you still need to use a SAS, use a container-level access policy when creating a SAS.</summary>
internal static string @UseContainerLevelAccessPolicyMessage => GetResourceString("UseContainerLevelAccessPolicyMessage");
/// <summary>Applications available over HTTPS must use secure cookies.</summary>
internal static string @UseSecureCookiesASPNetCoreDescription => GetResourceString("UseSecureCookiesASPNetCoreDescription");
/// <summary>Use SharedAccessProtocol HttpsOnly</summary>
internal static string @UseSharedAccessProtocolHttpsOnly => GetResourceString("UseSharedAccessProtocolHttpsOnly");
/// <summary>HTTPS encrypts network traffic. Use HttpsOnly, rather than HttpOrHttps, to ensure network traffic is always encrypted to help prevent disclosure of sensitive data.</summary>
internal static string @UseSharedAccessProtocolHttpsOnlyDescription => GetResourceString("UseSharedAccessProtocolHttpsOnlyDescription");
/// <summary>Consider using Azure's role-based access control instead of a Shared Access Signature (SAS) if possible. If you still need to use a SAS, specify SharedAccessProtocol.HttpsOnly.</summary>
internal static string @UseSharedAccessProtocolHttpsOnlyMessage => GetResourceString("UseSharedAccessProtocolHttpsOnlyMessage");
/// <summary>Processing XML from untrusted data may load dangerous external references, which should be restricted by using an XmlReader with a secure resolver or with DTD processing disabled.</summary>
internal static string @UseXmlReaderDescription => GetResourceString("UseXmlReaderDescription");
/// <summary>Use XmlReader for 'DataSet.ReadXml()'</summary>
internal static string @UseXmlReaderForDataSetReadXml => GetResourceString("UseXmlReaderForDataSetReadXml");
/// <summary>Use XmlReader for 'XmlSerializer.Deserialize()'</summary>
internal static string @UseXmlReaderForDeserialize => GetResourceString("UseXmlReaderForDeserialize");
/// <summary>Use XmlReader for 'XmlSchema.Read()'</summary>
internal static string @UseXmlReaderForSchemaRead => GetResourceString("UseXmlReaderForSchemaRead");
/// <summary>Use XmlReader for XmlValidatingReader constructor</summary>
internal static string @UseXmlReaderForValidatingReader => GetResourceString("UseXmlReaderForValidatingReader");
/// <summary>Use XmlReader for XPathDocument constructor</summary>
internal static string @UseXmlReaderForXPathDocument => GetResourceString("UseXmlReaderForXPathDocument");
/// <summary>This overload of the '{0}.{1}' method is potentially unsafe. It may enable Document Type Definition (DTD) which can be vulnerable to denial of service attacks, or might use an XmlResolver which can be vulnerable to information disclosure. Use an overload t ...</summary>
internal static string @UseXmlReaderMessage => GetResourceString("UseXmlReaderMessage");
/// <summary>Use Rivest-Shamir-Adleman (RSA) Algorithm With Sufficient Key Size</summary>
internal static string @UseRSAWithSufficientKeySize => GetResourceString("UseRSAWithSufficientKeySize");
/// <summary>Encryption algorithms are vulnerable to brute force attacks when too small a key size is used.</summary>
internal static string @UseRSAWithSufficientKeySizeDescription => GetResourceString("UseRSAWithSufficientKeySizeDescription");
/// <summary>Asymmetric encryption algorithm {0}'s key size is less than 2048. Switch to an RSA with at least 2048 key size, ECDH or ECDSA algorithm instead.</summary>
internal static string @UseRSAWithSufficientKeySizeMessage => GetResourceString("UseRSAWithSufficientKeySizeMessage");
/// <summary>Do Not Use Weak Key Derivation Function With Insufficient Iteration Count</summary>
internal static string @DefinitelyUseWeakKDFInsufficientIterationCount => GetResourceString("DefinitelyUseWeakKDFInsufficientIterationCount");
/// <summary>Use at least {0} iterations when deriving a cryptographic key from a password. By default, Rfc2898DeriveByte's IterationCount is only 1000</summary>
internal static string @DefinitelyUseWeakKDFInsufficientIterationCountMessage => GetResourceString("DefinitelyUseWeakKDFInsufficientIterationCountMessage");
/// <summary>When deriving cryptographic keys from user-provided inputs such as password, use sufficient iteration count (at least 100k).</summary>
internal static string @DoNotUseWeakKDFInsufficientIterationCountDescription => GetResourceString("DoNotUseWeakKDFInsufficientIterationCountDescription");
/// <summary>Ensure Sufficient Iteration Count When Using Weak Key Derivation Function</summary>
internal static string @MaybeUseWeakKDFInsufficientIterationCount => GetResourceString("MaybeUseWeakKDFInsufficientIterationCount");
/// <summary>Ensure that the iteration count is at least {0} when deriving a cryptographic key from a password. By default, Rfc2898DeriveByte's IterationCount is only 1000</summary>
internal static string @MaybeUseWeakKDFInsufficientIterationCountMessage => GetResourceString("MaybeUseWeakKDFInsufficientIterationCountMessage");
/// <summary>Do Not Add Archive Item's Path To The Target File System Path</summary>
internal static string @DoNotAddArchiveItemPathToTheTargetFileSystemPath => GetResourceString("DoNotAddArchiveItemPathToTheTargetFileSystemPath");
/// <summary>When extracting files from an archive and using the archive item's path, check if the path is safe. Archive path can be relative and can lead to file system access outside of the expected file system target path, leading to malicious config changes and rem ...</summary>
internal static string @DoNotAddArchiveItemPathToTheTargetFileSystemPathDescription => GetResourceString("DoNotAddArchiveItemPathToTheTargetFileSystemPathDescription");
/// <summary>When creating path for '{0} in method {1}' from relative archive item path to extract file and the source is an untrusted zip archive, make sure to sanitize relative archive item path '{2} in method {3}'</summary>
internal static string @DoNotAddArchiveItemPathToTheTargetFileSystemPathMessage => GetResourceString("DoNotAddArchiveItemPathToTheTargetFileSystemPathMessage");
/// <summary>Do not call Enumerable.Cast<T> or Enumerable.OfType<T> with incompatible types</summary>
internal static string @DoNotCallEnumerableCastOrOfTypeWithIncompatibleTypesTitle => GetResourceString("DoNotCallEnumerableCastOrOfTypeWithIncompatibleTypesTitle");
/// <summary>This call will always result in an empty sequence because type '{0}' is incompatible with type '{1}'</summary>
internal static string @DoNotCallEnumerableCastOrOfTypeWithIncompatibleTypesMessageOfType => GetResourceString("DoNotCallEnumerableCastOrOfTypeWithIncompatibleTypesMessageOfType");
/// <summary>Do not create tasks without passing a TaskScheduler</summary>
internal static string @DoNotCreateTasksWithoutPassingATaskSchedulerTitle => GetResourceString("DoNotCreateTasksWithoutPassingATaskSchedulerTitle");
/// <summary>Do not create tasks unless you are using one of the overloads that takes a TaskScheduler. The default is to schedule on TaskScheduler.Current, which would lead to deadlocks. Either use TaskScheduler.Default to schedule on the thread pool, or explicitly pas ...</summary>
internal static string @DoNotCreateTasksWithoutPassingATaskSchedulerDescription => GetResourceString("DoNotCreateTasksWithoutPassingATaskSchedulerDescription");
/// <summary>Do not create tasks without passing a TaskScheduler</summary>
internal static string @DoNotCreateTasksWithoutPassingATaskSchedulerMessage => GetResourceString("DoNotCreateTasksWithoutPassingATaskSchedulerMessage");
/// <summary>Adding a finalizer to a type derived from MemoryManager<T> may permit memory to be freed while it is still in use by a Span<T>.</summary>
internal static string @DoNotDefineFinalizersForTypesDerivedFromMemoryManagerDescription => GetResourceString("DoNotDefineFinalizersForTypesDerivedFromMemoryManagerDescription");
/// <summary>Adding a finalizer to a type derived from MemoryManager<T> may permit memory to be freed while it is still in use by a Span<T></summary>
internal static string @DoNotDefineFinalizersForTypesDerivedFromMemoryManagerMessage => GetResourceString("DoNotDefineFinalizersForTypesDerivedFromMemoryManagerMessage");
/// <summary>Do not define finalizers for types derived from MemoryManager<T></summary>
internal static string @DoNotDefineFinalizersForTypesDerivedFromMemoryManagerTitle => GetResourceString("DoNotDefineFinalizersForTypesDerivedFromMemoryManagerTitle");
/// <summary>Use ValueTasks correctly</summary>
internal static string @UseValueTasksCorrectlyTitle => GetResourceString("UseValueTasksCorrectlyTitle");
/// <summary>ValueTasks returned from member invocations are intended to be directly awaited. Attempts to consume a ValueTask multiple times or to directly access one's result before it's known to be completed may result in an exception or corruption. Ignoring such a ...</summary>
internal static string @UseValueTasksCorrectlyDescription => GetResourceString("UseValueTasksCorrectlyDescription");
/// <summary>ValueTask instances returned from method calls should be directly awaited, returned, or passed as an argument to another method call. Other usage, such as storing an instance into a local or a field, is likely an indication of a bug, as ValueTask instances ...</summary>
internal static string @UseValueTasksCorrectlyMessage_General => GetResourceString("UseValueTasksCorrectlyMessage_General");
/// <summary>ValueTask instances returned from method calls should always be used, typically awaited. Not doing so often represents a functional bug, but even if it doesn't, it can result in degraded performance if the target method pools objects for use with ValueTask ...</summary>
internal static string @UseValueTasksCorrectlyMessage_Unconsumed => GetResourceString("UseValueTasksCorrectlyMessage_Unconsumed");
/// <summary>ValueTask instances should only be consumed once, such as via an await. Consuming the same ValueTask instance multiple times can result in exceptions and data corruption.</summary>
internal static string @UseValueTasksCorrectlyMessage_DoubleConsumption => GetResourceString("UseValueTasksCorrectlyMessage_DoubleConsumption");
/// <summary>ValueTask instances should not have their result directly accessed unless the instance has already completed. Unlike Tasks, calling Result or GetAwaiter().GetResult() on a ValueTask is not guaranteed to block until the operation completes. If you can't sim ...</summary>
internal static string @UseValueTasksCorrectlyMessage_AccessingIncompleteResult => GetResourceString("UseValueTasksCorrectlyMessage_AccessingIncompleteResult");
/// <summary>Do not use ConfigureAwaitOptions.SuppressThrowing with Task<TResult></summary>
internal static string @DoNotUseConfigureAwaitWithSuppressThrowingTitle => GetResourceString("DoNotUseConfigureAwaitWithSuppressThrowingTitle");
/// <summary>The ConfigureAwaitOptions.SuppressThrowing option is only supported with the non-generic Task</summary>
internal static string @DoNotUseConfigureAwaitWithSuppressThrowingMessage => GetResourceString("DoNotUseConfigureAwaitWithSuppressThrowingMessage");
/// <summary>The ConfigureAwaitOptions.SuppressThrowing option is only supported with the non-generic Task, not a Task<TResult>. To use it with a Task<TResult>, first cast to the base Task.</summary>
internal static string @DoNotUseConfigureAwaitWithSuppressThrowingDescription => GetResourceString("DoNotUseConfigureAwaitWithSuppressThrowingDescription");
/// <summary>Argument passed to TaskCompletionSource constructor should be TaskCreationOptions enum instead of TaskContinuationOptions enum</summary>
internal static string @DoNotCreateTaskCompletionSourceWithWrongArgumentsTitle => GetResourceString("DoNotCreateTaskCompletionSourceWithWrongArgumentsTitle");
/// <summary>TaskCompletionSource has constructors that take TaskCreationOptions that control the underlying Task, and constructors that take object state that's stored in the task. Accidentally passing a TaskContinuationOptions instead of a TaskCreationOptions will r ...</summary>
internal static string @DoNotCreateTaskCompletionSourceWithWrongArgumentsDescription => GetResourceString("DoNotCreateTaskCompletionSourceWithWrongArgumentsDescription");
/// <summary>Argument contains TaskContinuationsOptions enum instead of TaskCreationOptions enum</summary>
internal static string @DoNotCreateTaskCompletionSourceWithWrongArgumentsMessage => GetResourceString("DoNotCreateTaskCompletionSourceWithWrongArgumentsMessage");
/// <summary>Replace TaskContinuationOptions with TaskCreationOptions.</summary>
internal static string @DoNotCreateTaskCompletionSourceWithWrongArgumentsFix => GetResourceString("DoNotCreateTaskCompletionSourceWithWrongArgumentsFix");
/// <summary>When deserializing untrusted input, allowing arbitrary types to be deserialized is insecure. When using deserializing JsonSerializer, use TypeNameHandling.None, or for values other than None, restrict deserialized types with a SerializationBinder.</summary>
internal static string @JsonNetInsecureSerializerMessage => GetResourceString("JsonNetInsecureSerializerMessage");
/// <summary>Do not deserialize with JsonSerializer using an insecure configuration</summary>
internal static string @JsonNetInsecureSerializerTitle => GetResourceString("JsonNetInsecureSerializerTitle");
/// <summary>When deserializing untrusted input, allowing arbitrary types to be deserialized is insecure. When using deserializing JsonSerializer, use TypeNameHandling.None, or for values other than None, restrict deserialized types with a SerializationBinder.</summary>
internal static string @JsonNetMaybeInsecureSerializerMessage => GetResourceString("JsonNetMaybeInsecureSerializerMessage");
/// <summary>Ensure that JsonSerializer has a secure configuration when deserializing</summary>
internal static string @JsonNetMaybeInsecureSerializerTitle => GetResourceString("JsonNetMaybeInsecureSerializerTitle");
/// <summary>Use DefaultDllImportSearchPaths attribute for P/Invokes</summary>
internal static string @UseDefaultDllImportSearchPathsAttribute => GetResourceString("UseDefaultDllImportSearchPathsAttribute");
/// <summary>By default, P/Invokes using DllImportAttribute probe a number of directories, including the current working directory for the library to load. This can be a security issue for certain applications, leading to DLL hijacking.</summary>
internal static string @UseDefaultDllImportSearchPathsAttributeDescription => GetResourceString("UseDefaultDllImportSearchPathsAttributeDescription");
/// <summary>The method {0} didn't use DefaultDllImportSearchPaths attribute for P/Invokes.</summary>
internal static string @UseDefaultDllImportSearchPathsAttributeMessage => GetResourceString("UseDefaultDllImportSearchPathsAttributeMessage");
/// <summary>Do not use unsafe DllImportSearchPath value</summary>
internal static string @DoNotUseUnsafeDllImportSearchPath => GetResourceString("DoNotUseUnsafeDllImportSearchPath");
/// <summary>There could be a malicious DLL in the default DLL search directories. Or, depending on where your application is run from, there could be a malicious DLL in the application's directory. Use a DllImportSearchPath value that specifies an explicit search path ...</summary>
internal static string @DoNotUseUnsafeDllImportSearchPathDescription => GetResourceString("DoNotUseUnsafeDllImportSearchPathDescription");
/// <summary>Use of unsafe DllImportSearchPath value {0}</summary>
internal static string @DoNotUseUnsafeDllImportSearchPathMessage => GetResourceString("DoNotUseUnsafeDllImportSearchPathMessage");
/// <summary>Use antiforgery tokens in ASP.NET Core MVC controllers</summary>
internal static string @UseAutoValidateAntiforgeryToken => GetResourceString("UseAutoValidateAntiforgeryToken");
/// <summary>Handling a POST, PUT, PATCH, or DELETE request without validating an antiforgery token may be vulnerable to cross-site request forgery attacks. A cross-site request forgery attack can send malicious requests from an authenticated user to your ASP.NET Core ...</summary>
internal static string @UseAutoValidateAntiforgeryTokenDescription => GetResourceString("UseAutoValidateAntiforgeryTokenDescription");
/// <summary>Method {0} handles a {1} request without performing antiforgery token validation. You also need to ensure that your HTML form sends an antiforgery token.</summary>
internal static string @UseAutoValidateAntiforgeryTokenMessage => GetResourceString("UseAutoValidateAntiforgeryTokenMessage");
/// <summary>Miss HttpVerb attribute for action methods</summary>
internal static string @MissHttpVerbAttribute => GetResourceString("MissHttpVerbAttribute");
/// <summary>Action method {0} needs to specify the HTTP request kind explicitly</summary>
internal static string @MissHttpVerbAttributeMessage => GetResourceString("MissHttpVerbAttributeMessage");
/// <summary>Do not use insecure randomness</summary>
internal static string @DoNotUseInsecureRandomness => GetResourceString("DoNotUseInsecureRandomness");
/// <summary>{0} is an insecure random number generator. Use cryptographically secure random number generators when randomness is required for security.</summary>
internal static string @DoNotUseInsecureRandomnessMessage => GetResourceString("DoNotUseInsecureRandomnessMessage");
/// <summary>Using a cryptographically weak pseudo-random number generator may allow an attacker to predict what security-sensitive value will be generated. Use a cryptographically strong random number generator if an unpredictable value is required, or ensure that wea ...</summary>
internal static string @DoNotUseInsecureRandomnessDescription => GetResourceString("DoNotUseInsecureRandomnessDescription");
/// <summary>For non-empty collections, CountAsync() and LongCountAsync() enumerate the entire sequence, while AnyAsync() stops at the first item or the first item that satisfies a condition.</summary>
internal static string @DoNotUseCountAsyncWhenAnyAsyncCanBeUsedDescription => GetResourceString("DoNotUseCountAsyncWhenAnyAsyncCanBeUsedDescription");
/// <summary>{0}() is used where AnyAsync() could be used instead to improve performance</summary>
internal static string @DoNotUseCountAsyncWhenAnyAsyncCanBeUsedMessage => GetResourceString("DoNotUseCountAsyncWhenAnyAsyncCanBeUsedMessage");
/// <summary>Do not use CountAsync() or LongCountAsync() when AnyAsync() can be used</summary>
internal static string @DoNotUseCountAsyncWhenAnyAsyncCanBeUsedTitle => GetResourceString("DoNotUseCountAsyncWhenAnyAsyncCanBeUsedTitle");
/// <summary>Enumerable.Count() potentially enumerates the sequence while a Length/Count property is a direct access.</summary>
internal static string @UsePropertyInsteadOfCountMethodWhenAvailableDescription => GetResourceString("UsePropertyInsteadOfCountMethodWhenAvailableDescription");
/// <summary>Use the "{0}" property instead of Enumerable.Count()</summary>
internal static string @UsePropertyInsteadOfCountMethodWhenAvailableMessage => GetResourceString("UsePropertyInsteadOfCountMethodWhenAvailableMessage");
/// <summary>Use Length/Count property instead of Count() when available</summary>
internal static string @UsePropertyInsteadOfCountMethodWhenAvailableTitle => GetResourceString("UsePropertyInsteadOfCountMethodWhenAvailableTitle");
/// <summary>Set HttpOnly to true for HttpCookie</summary>
internal static string @SetHttpOnlyForHttpCookie => GetResourceString("SetHttpOnlyForHttpCookie");
/// <summary>As a defense in depth measure, ensure security sensitive HTTP cookies are marked as HttpOnly. This indicates web browsers should disallow scripts from accessing the cookies. Injected malicious scripts are a common way of stealing cookies.</summary>
internal static string @SetHttpOnlyForHttpCookieDescription => GetResourceString("SetHttpOnlyForHttpCookieDescription");
/// <summary>HttpCookie.HttpOnly is set to false or not set at all when using an HttpCookie. Ensure security sensitive cookies are marked as HttpOnly to prevent malicious scripts from stealing the cookies</summary>
internal static string @SetHttpOnlyForHttpCookieMessage => GetResourceString("SetHttpOnlyForHttpCookieMessage");
/// <summary>Older protocol versions of Transport Layer Security (TLS) are less secure than TLS 1.2 and TLS 1.3, and are more likely to have new vulnerabilities. Avoid older protocol versions to minimize risk.</summary>
internal static string @DeprecatedSslProtocolsDescription => GetResourceString("DeprecatedSslProtocolsDescription");
/// <summary>Transport Layer Security protocol version '{0}' is deprecated. Use 'None' to let the Operating System choose a version.</summary>
internal static string @DeprecatedSslProtocolsMessage => GetResourceString("DeprecatedSslProtocolsMessage");
/// <summary>Do not use deprecated SslProtocols values</summary>
internal static string @DeprecatedSslProtocolsTitle => GetResourceString("DeprecatedSslProtocolsTitle");
/// <summary>Current Transport Layer Security protocol versions may become deprecated if vulnerabilities are found. Avoid hardcoding SslProtocols values to keep your application secure. Use 'None' to let the Operating System choose a version.</summary>
internal static string @HardcodedSslProtocolsDescription => GetResourceString("HardcodedSslProtocolsDescription");
/// <summary>Avoid hardcoding SslProtocols '{0}' to ensure your application remains secure in the future. Use 'None' to let the Operating System choose a version.</summary>
internal static string @HardcodedSslProtocolsMessage => GetResourceString("HardcodedSslProtocolsMessage");
/// <summary>Avoid hardcoded SslProtocols values</summary>
internal static string @HardcodedSslProtocolsTitle => GetResourceString("HardcodedSslProtocolsTitle");
/// <summary>All the methods that create, edit, delete, or otherwise modify data do so in the [HttpPost] overload of the method, which needs to be protected with the anti forgery attribute from request forgery. Performing a GET operation should be a safe operation that ...</summary>
internal static string @MissHttpVerbAttributeDescription => GetResourceString("MissHttpVerbAttributeDescription");
/// <summary>HttpClients should enable certificate revocation list checks</summary>
internal static string @DefinitelyDisableHttpClientCRLCheck => GetResourceString("DefinitelyDisableHttpClientCRLCheck");
/// <summary>HttpClient is created without enabling CheckCertificateRevocationList</summary>
internal static string @DefinitelyDisableHttpClientCRLCheckMessage => GetResourceString("DefinitelyDisableHttpClientCRLCheckMessage");
/// <summary>Using HttpClient without providing a platform specific handler (WinHttpHandler or CurlHandler or HttpClientHandler) where the CheckCertificateRevocationList property is set to true, will allow revoked certificates to be accepted by the HttpClient as valid.</summary>
internal static string @DoNotDisableHttpClientCRLCheckDescription => GetResourceString("DoNotDisableHttpClientCRLCheckDescription");
/// <summary>Ensure HttpClient certificate revocation list check is not disabled</summary>
internal static string @MaybeDisableHttpClientCRLCheck => GetResourceString("MaybeDisableHttpClientCRLCheck");
/// <summary>HttpClient may be created without enabling CheckCertificateRevocationList</summary>
internal static string @MaybeDisableHttpClientCRLCheckMessage => GetResourceString("MaybeDisableHttpClientCRLCheckMessage");
/// <summary>Do not hard-code certificate</summary>
internal static string @DoNotHardCodeCertificate => GetResourceString("DoNotHardCodeCertificate");
/// <summary>Hard-coded certificates in source code are vulnerable to being exploited.</summary>
internal static string @DoNotHardCodeCertificateDescription => GetResourceString("DoNotHardCodeCertificateDescription");
/// <summary>Potential security vulnerability was found where '{0}' in method '{1}' may be tainted by hard-coded certificate from '{2}' in method '{3}'</summary>
internal static string @DoNotHardCodeCertificateMessage => GetResourceString("DoNotHardCodeCertificateMessage");
/// <summary>Do not use CreateEncryptor with non-default IV</summary>
internal static string @DefinitelyUseCreateEncryptorWithNonDefaultIV => GetResourceString("DefinitelyUseCreateEncryptorWithNonDefaultIV");
/// <summary>Symmetric encryption uses non-default initialization vector, which could be potentially repeatable</summary>
internal static string @DefinitelyUseCreateEncryptorWithNonDefaultIVMessage => GetResourceString("DefinitelyUseCreateEncryptorWithNonDefaultIVMessage");
/// <summary>Use CreateEncryptor with the default IV</summary>
internal static string @MaybeUseCreateEncryptorWithNonDefaultIV => GetResourceString("MaybeUseCreateEncryptorWithNonDefaultIV");
/// <summary>The non-default initialization vector, which can be potentially repeatable, is used in the encryption. Ensure use the default one.</summary>
internal static string @MaybeUseCreateEncryptorWithNonDefaultIVMessage => GetResourceString("MaybeUseCreateEncryptorWithNonDefaultIVMessage");
/// <summary>Symmetric encryption should always use a non-repeatable initialization vector to prevent dictionary attacks.</summary>
internal static string @DoNotUseCreateEncryptorWithNonDefaultIVDescription => GetResourceString("DoNotUseCreateEncryptorWithNonDefaultIVDescription");
/// <summary>The method '{0}' is insecure when deserializing untrusted data</summary>
internal static string @DataTableReadXmlMessage => GetResourceString("DataTableReadXmlMessage");
/// <summary>Do not use DataTable.ReadXml() with untrusted data</summary>
internal static string @DataTableReadXmlTitle => GetResourceString("DataTableReadXmlTitle");
/// <summary>When deserializing untrusted input, deserializing a {0} object is insecure. '{1}' either is or derives from {0}</summary>
internal static string @DataSetDataTableInSerializableTypeMessage => GetResourceString("DataSetDataTableInSerializableTypeMessage");
/// <summary>When deserializing untrusted input, deserializing a {0} object is insecure. '{1}' either is or derives from {0}</summary>
internal static string @DataSetDataTableInWebDeserializableObjectGraphMessage => GetResourceString("DataSetDataTableInWebDeserializableObjectGraphMessage");
/// <summary>Unsafe DataSet or DataTable type in web deserializable object graph</summary>
internal static string @DataSetDataTableInWebDeserializableObjectGraphTitle => GetResourceString("DataSetDataTableInWebDeserializableObjectGraphTitle");
/// <summary>The method '{0}' is insecure when deserializing untrusted data</summary>
internal static string @DataSetReadXmlMessage => GetResourceString("DataSetReadXmlMessage");
/// <summary>Do not use DataSet.ReadXml() with untrusted data</summary>
internal static string @DataSetReadXmlTitle => GetResourceString("DataSetReadXmlTitle");
/// <summary>When deserializing untrusted input with an IFormatter-based serializer, deserializing a {0} object is insecure. '{1}' either is or derives from {0}.</summary>
internal static string @DataSetDataTableInRceSerializableTypeMessage => GetResourceString("DataSetDataTableInRceSerializableTypeMessage");
/// <summary>When deserializing untrusted input, deserializing a {0} object is insecure. '{1}' either is or derives from {0}</summary>
internal static string @DataSetDataTableInDeserializableObjectGraphMessage => GetResourceString("DataSetDataTableInDeserializableObjectGraphMessage");
/// <summary>Unsafe DataSet or DataTable type found in deserializable object graph</summary>
internal static string @DataSetDataTableInDeserializableObjectGraphTitle => GetResourceString("DataSetDataTableInDeserializableObjectGraphTitle");
/// <summary>When deserializing untrusted input, deserializing a {0} object is insecure. '{1}' either is or derives from {0}</summary>
internal static string @DataSetDataTableInRceDeserializableObjectGraphMessage => GetResourceString("DataSetDataTableInRceDeserializableObjectGraphMessage");
/// <summary>Unsafe DataSet or DataTable in deserialized object graph can be vulnerable to remote code execution attacks</summary>
internal static string @DataSetDataTableInRceDeserializableObjectGraphTitle => GetResourceString("DataSetDataTableInRceDeserializableObjectGraphTitle");
/// <summary>When deserializing untrusted input with an IFormatter-based serializer, deserializing a {0} object is insecure. '{1}' either is or derives from {0}. Ensure that the auto-generated type is never deserialized with untrusted data.</summary>
internal static string @DataSetDataTableInRceAutogeneratedSerializableTypeMessage => GetResourceString("DataSetDataTableInRceAutogeneratedSerializableTypeMessage");
/// <summary>Unsafe DataSet or DataTable in auto-generated serializable type can be vulnerable to remote code execution attacks</summary>
internal static string @DataSetDataTableInRceAutogeneratedSerializableTypeTitle => GetResourceString("DataSetDataTableInRceAutogeneratedSerializableTypeTitle");
/// <summary>Unsafe DataSet or DataTable in serializable type can be vulnerable to remote code execution attacks</summary>
internal static string @DataSetDataTableInRceSerializableTypeTitle => GetResourceString("DataSetDataTableInRceSerializableTypeTitle");
/// <summary>Unsafe DataSet or DataTable in serializable type</summary>
internal static string @DataSetDataTableInSerializableTypeTitle => GetResourceString("DataSetDataTableInSerializableTypeTitle");
/// <summary>The method '{0}' is insecure when deserializing untrusted data. Make sure that auto-generated class containing the '{0}' call is not deserialized with untrusted data.</summary>
internal static string @DataSetReadXmlAutogeneratedMessage => GetResourceString("DataSetReadXmlAutogeneratedMessage");
/// <summary>Ensure auto-generated class containing DataSet.ReadXml() is not used with untrusted data</summary>
internal static string @DataSetReadXmlAutogeneratedTitle => GetResourceString("DataSetReadXmlAutogeneratedTitle");
/// <summary>Do not use stackalloc in loops</summary>
internal static string @DoNotUseStackallocInLoopsTitle => GetResourceString("DoNotUseStackallocInLoopsTitle");
/// <summary>Stack space allocated by a stackalloc is only released at the end of the current method's invocation. Using it in a loop can result in unbounded stack growth and eventual stack overflow conditions.</summary>
internal static string @DoNotUseStackallocInLoopsDescription => GetResourceString("DoNotUseStackallocInLoopsDescription");
/// <summary>Potential stack overflow. Move the stackalloc out of the loop.</summary>
internal static string @DoNotUseStackallocInLoopsMessage => GetResourceString("DoNotUseStackallocInLoopsMessage");
/// <summary>Prefer the 'Memory'-based overloads for 'ReadAsync' and 'WriteAsync'</summary>
internal static string @PreferStreamAsyncMemoryOverloadsTitle => GetResourceString("PreferStreamAsyncMemoryOverloadsTitle");
/// <summary>'Stream' has a 'ReadAsync' overload that takes a 'Memory<Byte>' as the first argument, and a 'WriteAsync' overload that takes a 'ReadOnlyMemory<Byte>' as the first argument. Prefer calling the memory based overloads, which are more efficient.</summary>
internal static string @PreferStreamAsyncMemoryOverloadsDescription => GetResourceString("PreferStreamAsyncMemoryOverloadsDescription");
/// <summary>Change the '{0}' method call to use the '{1}' overload</summary>
internal static string @PreferStreamAsyncMemoryOverloadsMessage => GetResourceString("PreferStreamAsyncMemoryOverloadsMessage");
/// <summary>Forward the 'CancellationToken' parameter to methods to ensure the operation cancellation notifications gets properly propagated, or pass in 'CancellationToken.None' explicitly to indicate intentionally not propagating the token.</summary>
internal static string @ForwardCancellationTokenToInvocationsDescription => GetResourceString("ForwardCancellationTokenToInvocationsDescription");
/// <summary>Forward the '{0}' parameter to the '{1}' method or pass in 'CancellationToken.None' explicitly to indicate intentionally not propagating the token</summary>
internal static string @ForwardCancellationTokenToInvocationsMessage => GetResourceString("ForwardCancellationTokenToInvocationsMessage");
/// <summary>Forward the 'CancellationToken' parameter to methods</summary>
internal static string @ForwardCancellationTokenToInvocationsTitle => GetResourceString("ForwardCancellationTokenToInvocationsTitle");
/// <summary>Change to call the two argument constructor, pass null for the message.</summary>
internal static string @InstantiateArgumentExceptionsCorrectlyChangeToTwoArgumentCodeFixTitle => GetResourceString("InstantiateArgumentExceptionsCorrectlyChangeToTwoArgumentCodeFixTitle");
/// <summary>Swap the arguments order</summary>
internal static string @InstantiateArgumentExceptionsCorrectlyFlipArgumentOrderCodeFixTitle => GetResourceString("InstantiateArgumentExceptionsCorrectlyFlipArgumentOrderCodeFixTitle");
/// <summary>Prefer strongly-typed Append and Insert method overloads on StringBuilder</summary>
internal static string @PreferTypedStringBuilderAppendOverloadsTitle => GetResourceString("PreferTypedStringBuilderAppendOverloadsTitle");
/// <summary>StringBuilder.Append and StringBuilder.Insert provide overloads for multiple types beyond System.String. When possible, prefer the strongly-typed overloads over using ToString() and the string-based overload. Additionally, prefer Append(char, int) over Ap ...</summary>
internal static string @PreferTypedStringBuilderAppendOverloadsDescription => GetResourceString("PreferTypedStringBuilderAppendOverloadsDescription");
/// <summary>Prefer strongly-typed StringBuilder overload</summary>
internal static string @PreferTypedStringBuilderAppendOverloadsMessage => GetResourceString("PreferTypedStringBuilderAppendOverloadsMessage");
/// <summary>Remove the ToString call</summary>
internal static string @PreferTypedStringBuilderAppendOverloadsRemoveToString => GetResourceString("PreferTypedStringBuilderAppendOverloadsRemoveToString");
/// <summary>Use StringBuilder.Append(char, int) overload</summary>
internal static string @PreferTypedStringBuilderAppendOverloadsReplaceStringConstructor => GetResourceString("PreferTypedStringBuilderAppendOverloadsReplaceStringConstructor");
/// <summary>Calls to 'string.IndexOf' where the result is used to check for the presence/absence of a substring can be replaced by 'string.Contains'.</summary>
internal static string @PreferStringContainsOverIndexOfDescription => GetResourceString("PreferStringContainsOverIndexOfDescription");
/// <summary>Use 'string.Contains' instead of 'string.IndexOf' to improve readability</summary>
internal static string @PreferStringContainsOverIndexOfMessage => GetResourceString("PreferStringContainsOverIndexOfMessage");
/// <summary>Consider using 'string.Contains' instead of 'string.IndexOf'</summary>
internal static string @PreferStringContainsOverIndexOfTitle => GetResourceString("PreferStringContainsOverIndexOfTitle");
/// <summary>'StringBuilder.Append(char)' is more efficient than 'StringBuilder.Append(string)' when the string is a single character. When calling 'Append' with a constant, prefer using a constant char rather than a constant string containing one character.</summary>
internal static string @PreferConstCharOverConstUnitStringInStringBuilderDescription => GetResourceString("PreferConstCharOverConstUnitStringInStringBuilderDescription");
/// <summary>Use 'StringBuilder.Append(char)' instead of 'StringBuilder.Append(string)' when the input is a constant unit string</summary>
internal static string @PreferConstCharOverConstUnitStringInStringBuilderMessage => GetResourceString("PreferConstCharOverConstUnitStringInStringBuilderMessage");
/// <summary>Consider using 'StringBuilder.Append(char)' when applicable</summary>
internal static string @PreferConstCharOverConstUnitStringInStringBuilderTitle => GetResourceString("PreferConstCharOverConstUnitStringInStringBuilderTitle");
/// <summary>'Enum.HasFlag' method expects the 'enum' argument to be of the same 'enum' type as the instance on which the method is invoked and that this 'enum' is marked with 'System.FlagsAttribute'. If these are different 'enum' types, an unhandled exception will be ...</summary>
internal static string @ProvideCorrectArgumentToEnumHasFlagDescription => GetResourceString("ProvideCorrectArgumentToEnumHasFlagDescription");
/// <summary>Set 'MaxResponseHeadersLength' properly</summary>
internal static string @ProvideHttpClientHandlerMaxResponseHeaderLengthValueCorrectlyTitle => GetResourceString("ProvideHttpClientHandlerMaxResponseHeaderLengthValueCorrectlyTitle");
/// <summary>Make sure the value '{0}' is correct. This value is measured in kilobytes, not bytes.</summary>
internal static string @ProvideHttpClientHandlerMaxResponseHeaderLengthValueCorrectlyMessage => GetResourceString("ProvideHttpClientHandlerMaxResponseHeaderLengthValueCorrectlyMessage");
/// <summary>The property 'MaxResponseHeadersLength' is measured in kilobytes, not in bytes. The provided value is multiplied by 1024, which might be greater than your intended maximum length.</summary>
internal static string @ProvideHttpClientHandlerMaxResponseHeaderLengthValueCorrectlyDescription => GetResourceString("ProvideHttpClientHandlerMaxResponseHeaderLengthValueCorrectlyDescription");
/// <summary>The argument type, '{0}', must be the same as the enum type '{1}'</summary>
internal static string @ProvideCorrectArgumentToEnumHasFlagMessageDifferentType => GetResourceString("ProvideCorrectArgumentToEnumHasFlagMessageDifferentType");
/// <summary>Provide correct 'enum' argument to 'Enum.HasFlag'</summary>
internal static string @ProvideCorrectArgumentToEnumHasFlagTitle => GetResourceString("ProvideCorrectArgumentToEnumHasFlagTitle");
/// <summary>For determining whether the object contains or not any items, prefer using 'IsEmpty' property rather than retrieving the number of items from the 'Count' property and comparing it to 0 or 1.</summary>
internal static string @PreferIsEmptyOverCountDescription => GetResourceString("PreferIsEmptyOverCountDescription");
/// <summary>Prefer 'IsEmpty' over 'Count' to determine whether the object is empty</summary>
internal static string @PreferIsEmptyOverCountMessage => GetResourceString("PreferIsEmptyOverCountMessage");
/// <summary>Prefer IsEmpty over Count</summary>
internal static string @PreferIsEmptyOverCountTitle => GetResourceString("PreferIsEmptyOverCountTitle");
/// <summary>'Environment.ProcessId' is simpler and faster than 'Process.GetCurrentProcess().Id'.</summary>
internal static string @UseEnvironmentProcessIdDescription => GetResourceString("UseEnvironmentProcessIdDescription");
/// <summary>Use 'Environment.ProcessId' instead of 'Process.GetCurrentProcess().Id'</summary>
internal static string @UseEnvironmentProcessIdMessage => GetResourceString("UseEnvironmentProcessIdMessage");
/// <summary>Use 'Environment.ProcessId'</summary>
internal static string @UseEnvironmentProcessIdTitle => GetResourceString("UseEnvironmentProcessIdTitle");
/// <summary>Use 'Environment.ProcessId'</summary>
internal static string @UseEnvironmentProcessIdFix => GetResourceString("UseEnvironmentProcessIdFix");
/// <summary>'Environment.ProcessPath' is simpler and faster than 'Process.GetCurrentProcess().MainModule.FileName'.</summary>
internal static string @UseEnvironmentProcessPathDescription => GetResourceString("UseEnvironmentProcessPathDescription");
/// <summary>Use 'Environment.ProcessPath' instead of 'Process.GetCurrentProcess().MainModule.FileName'</summary>
internal static string @UseEnvironmentProcessPathMessage => GetResourceString("UseEnvironmentProcessPathMessage");
/// <summary>Use 'Environment.ProcessPath'</summary>
internal static string @UseEnvironmentProcessPathTitle => GetResourceString("UseEnvironmentProcessPathTitle");
/// <summary>Use 'Environment.ProcessPath'</summary>
internal static string @UseEnvironmentProcessPathFix => GetResourceString("UseEnvironmentProcessPathFix");
/// <summary>'Environment.CurrentManagedThreadId' is simpler and faster than 'Thread.CurrentThread.ManagedThreadId'.</summary>
internal static string @UseEnvironmentCurrentManagedThreadIdDescription => GetResourceString("UseEnvironmentCurrentManagedThreadIdDescription");
/// <summary>Use 'Environment.CurrentManagedThreadId' instead of 'Thread.CurrentThread.ManagedThreadId'</summary>
internal static string @UseEnvironmentCurrentManagedThreadIdMessage => GetResourceString("UseEnvironmentCurrentManagedThreadIdMessage");
/// <summary>Use 'Environment.CurrentManagedThreadId'</summary>
internal static string @UseEnvironmentCurrentManagedThreadIdTitle => GetResourceString("UseEnvironmentCurrentManagedThreadIdTitle");
/// <summary>Use 'Environment.CurrentManagedThreadId'</summary>
internal static string @UseEnvironmentCurrentManagedThreadIdFix => GetResourceString("UseEnvironmentCurrentManagedThreadIdFix");
/// <summary>'Regex.Count' is simpler and faster than 'Regex.Matches(...).Count'.</summary>
internal static string @UseRegexCountDescription => GetResourceString("UseRegexCountDescription");
/// <summary>Use 'Regex.Count' instead of 'Regex.Matches(...).Count'</summary>
internal static string @UseRegexCountMessage => GetResourceString("UseRegexCountMessage");
/// <summary>Use 'Regex.Count'</summary>
internal static string @UseRegexCountTitle => GetResourceString("UseRegexCountTitle");
/// <summary>Use 'Regex.Count'</summary>
internal static string @UseRegexCountFix => GetResourceString("UseRegexCountFix");
/// <summary>'Regex.IsMatch' is simpler and faster than 'Regex.Match(...).Success'.</summary>
internal static string @UseRegexIsMatchDescription => GetResourceString("UseRegexIsMatchDescription");
/// <summary>Use 'Regex.IsMatch' instead of 'Regex.Match(...).Success'</summary>
internal static string @UseRegexIsMatchMessage => GetResourceString("UseRegexIsMatchMessage");
/// <summary>Use 'Regex.IsMatch'</summary>
internal static string @UseRegexIsMatchTitle => GetResourceString("UseRegexIsMatchTitle");
/// <summary>Use 'Regex.IsMatch'</summary>
internal static string @UseRegexIsMatchFix => GetResourceString("UseRegexIsMatchFix");
/// <summary>'ThreadStatic' only affects static fields. When applied to instance fields, it has no impact on behavior.</summary>
internal static string @ThreadStaticOnNonStaticFieldDescription => GetResourceString("ThreadStaticOnNonStaticFieldDescription");
/// <summary>Ensure 'ThreadStatic' is only used with static fields</summary>
internal static string @ThreadStaticOnNonStaticFieldMessage => GetResourceString("ThreadStaticOnNonStaticFieldMessage");
/// <summary>'ThreadStatic' only affects static fields</summary>
internal static string @ThreadStaticOnNonStaticFieldTitle => GetResourceString("ThreadStaticOnNonStaticFieldTitle");
/// <summary>'ThreadStatic' fields should be initialized lazily on use, not with inline initialization nor explicitly in a static constructor, which would only initialize the field on the thread that runs the type's static constructor.</summary>
internal static string @ThreadStaticInitializedInlineDescription => GetResourceString("ThreadStaticInitializedInlineDescription");
/// <summary>'ThreadStatic' fields should not use inline initialization</summary>
internal static string @ThreadStaticInitializedInlineMessage => GetResourceString("ThreadStaticInitializedInlineMessage");
/// <summary>Improper 'ThreadStatic' field initialization</summary>
internal static string @ThreadStaticInitializedInlineTitle => GetResourceString("ThreadStaticInitializedInlineTitle");
/// <summary>Use `{0}` instead of Range-based indexers on a string</summary>
internal static string @UseAsSpanInsteadOfRangeIndexerOnAStringCodeFixTitle => GetResourceString("UseAsSpanInsteadOfRangeIndexerOnAStringCodeFixTitle");
/// <summary>Use `{0}` instead of Range-based indexers on an array</summary>
internal static string @UseAsSpanInsteadOfRangeIndexerOnAnArrayCodeFixTitle => GetResourceString("UseAsSpanInsteadOfRangeIndexerOnAnArrayCodeFixTitle");
/// <summary>Validate platform compatibility</summary>
internal static string @PlatformCompatibilityTitle => GetResourceString("PlatformCompatibilityTitle");
/// <summary>Using platform dependent API on a component makes the code no longer work across all platforms.</summary>
internal static string @PlatformCompatibilityDescription => GetResourceString("PlatformCompatibilityDescription");
/// <summary>This call site is unreachable on: {2}. '{0}' is only supported on: {1}.</summary>
internal static string @PlatformCompatibilityOnlySupportedCsUnreachableMessage => GetResourceString("PlatformCompatibilityOnlySupportedCsUnreachableMessage");
/// <summary>This call site is reachable on all platforms. '{0}' is unsupported on: {1}.</summary>
internal static string @PlatformCompatibilityUnsupportedCsAllPlatformMessage => GetResourceString("PlatformCompatibilityUnsupportedCsAllPlatformMessage");
/// <summary>String parameters passed by value with the 'OutAttribute' can destabilize the runtime if the string is an interned string.</summary>
internal static string @DoNotUseOutAttributeStringPInvokeParametersDescription => GetResourceString("DoNotUseOutAttributeStringPInvokeParametersDescription");
/// <summary>Do not use the 'OutAttribute' for string parameter '{0}' which is passed by value. If marshalling of modified data back to the caller is required, use the 'out' keyword to pass the string by reference instead.</summary>
internal static string @DoNotUseOutAttributeStringPInvokeParametersMessage => GetResourceString("DoNotUseOutAttributeStringPInvokeParametersMessage");
/// <summary>Do not use 'OutAttribute' on string parameters for P/Invokes</summary>
internal static string @DoNotUseOutAttributeStringPInvokeParametersTitle => GetResourceString("DoNotUseOutAttributeStringPInvokeParametersTitle");
/// <summary>Marshalling of 'StringBuilder' always creates a native buffer copy, resulting in multiple allocations for one marshalling operation.</summary>
internal static string @AvoidStringBuilderPInvokeParametersDescription => GetResourceString("AvoidStringBuilderPInvokeParametersDescription");
/// <summary>Avoid 'StringBuilder' parameters for P/Invokes. Consider using a character buffer instead.</summary>
internal static string @AvoidStringBuilderPInvokeParametersMessage => GetResourceString("AvoidStringBuilderPInvokeParametersMessage");
/// <summary>Avoid 'StringBuilder' parameters for P/Invokes</summary>
internal static string @AvoidStringBuilderPInvokeParametersTitle => GetResourceString("AvoidStringBuilderPInvokeParametersTitle");
/// <summary>This call site is reachable on: {2}. '{0}' is only supported on: {1}.</summary>
internal static string @PlatformCompatibilityOnlySupportedCsReachableMessage => GetResourceString("PlatformCompatibilityOnlySupportedCsReachableMessage");
/// <summary>This call site is reachable on all platforms. '{0}' is only supported on: {1}.</summary>
internal static string @PlatformCompatibilityOnlySupportedCsAllPlatformMessage => GetResourceString("PlatformCompatibilityOnlySupportedCsAllPlatformMessage");
/// <summary>Replace with 'string.Contains'</summary>
internal static string @PreferStringContainsOverIndexOfCodeFixTitle => GetResourceString("PreferStringContainsOverIndexOfCodeFixTitle");
/// <summary>,</summary>
internal static string @CommaSeparator => GetResourceString("CommaSeparator");
/// <summary>'{0}' from version {1} to {2}</summary>
internal static string @PlatformCompatibilityFromVersionToVersion => GetResourceString("PlatformCompatibilityFromVersionToVersion");
/// <summary>This call site is reachable on all platforms. '{0}' is supported on: {1}.</summary>
internal static string @PlatformCompatibilitySupportedCsAllPlatformMessage => GetResourceString("PlatformCompatibilitySupportedCsAllPlatformMessage");
/// <summary>This call site is reachable on: {2}. '{0}' is supported on: {1}.</summary>
internal static string @PlatformCompatibilitySupportedCsReachableMessage => GetResourceString("PlatformCompatibilitySupportedCsReachableMessage");
/// <summary>This call site is reachable on: {2}. '{0}' is unsupported on: {1}.</summary>
internal static string @PlatformCompatibilityUnsupportedCsReachableMessage => GetResourceString("PlatformCompatibilityUnsupportedCsReachableMessage");
/// <summary>'{0}' {1} and before</summary>
internal static string @PlatformCompatibilityVersionAndBefore => GetResourceString("PlatformCompatibilityVersionAndBefore");
/// <summary>'{0}' {1} and later</summary>
internal static string @PlatformCompatibilityVersionAndLater => GetResourceString("PlatformCompatibilityVersionAndLater");
/// <summary>'{0}' all versions</summary>
internal static string @PlatformCompatibilityAllVersions => GetResourceString("PlatformCompatibilityAllVersions");
/// <summary>and all other platforms</summary>
internal static string @PlatformCompatibilityAllPlatforms => GetResourceString("PlatformCompatibilityAllPlatforms");
/// <summary>Do not guard 'Dictionary.Remove(key)' with 'Dictionary.ContainsKey(key)'. The former already checks whether the key exists, and will not throw if it does not.</summary>
internal static string @DoNotGuardDictionaryRemoveByContainsKeyDescription => GetResourceString("DoNotGuardDictionaryRemoveByContainsKeyDescription");
/// <summary>Do not guard 'Dictionary.Remove(key)' with 'Dictionary.ContainsKey(key)'</summary>
internal static string @DoNotGuardDictionaryRemoveByContainsKeyMessage => GetResourceString("DoNotGuardDictionaryRemoveByContainsKeyMessage");
/// <summary>Unnecessary call to 'Dictionary.ContainsKey(key)'</summary>
internal static string @DoNotGuardDictionaryRemoveByContainsKeyTitle => GetResourceString("DoNotGuardDictionaryRemoveByContainsKeyTitle");
/// <summary>Do not guard 'Add(item)' or 'Remove(item)' with 'Contains(item)' for the set. The former two already check whether the item exists and will return if it was added or removed.</summary>
internal static string @DoNotGuardSetAddOrRemoveByContainsDescription => GetResourceString("DoNotGuardSetAddOrRemoveByContainsDescription");
/// <summary>Do not guard '{0}' with '{1}'</summary>
internal static string @DoNotGuardSetAddOrRemoveByContainsMessage => GetResourceString("DoNotGuardSetAddOrRemoveByContainsMessage");
/// <summary>Unnecessary call to 'Contains(item)'</summary>
internal static string @DoNotGuardSetAddOrRemoveByContainsTitle => GetResourceString("DoNotGuardSetAddOrRemoveByContainsTitle");
/// <summary>Remove unnecessary call</summary>
internal static string @RemoveRedundantGuardCallCodeFixTitle => GetResourceString("RemoveRedundantGuardCallCodeFixTitle");
/// <summary>'Buffer.BlockCopy' expects the number of bytes to be copied for the 'count' argument. Using 'Array.Length' may not match the number of bytes that needs to be copied.</summary>
internal static string @BufferBlockCopyLengthMessage => GetResourceString("BufferBlockCopyLengthMessage");
/// <summary>'Buffer.BlockCopy' expects the number of bytes to be copied for the 'count' argument</summary>
internal static string @BufferBlockCopyLengthTitle => GetResourceString("BufferBlockCopyLengthTitle");
/// <summary>'Buffer.BlockCopy' expects the number of bytes to be copied for the 'count' argument. Using 'Array.Length' may not match the number of bytes that needs to be copied.</summary>
internal static string @BufferBlockCopyDescription => GetResourceString("BufferBlockCopyDescription");
/// <summary>'AsSpan' is more efficient than 'Substring'. 'Substring' performs an O(n) string copy, while 'AsSpan' does not and has a constant cost.</summary>
internal static string @PreferAsSpanOverSubstringDescription => GetResourceString("PreferAsSpanOverSubstringDescription");
/// <summary>Prefer 'AsSpan' over 'Substring' when span-based overloads are available</summary>
internal static string @PreferAsSpanOverSubstringMessage => GetResourceString("PreferAsSpanOverSubstringMessage");
/// <summary>Prefer 'AsSpan' over 'Substring'</summary>
internal static string @PreferAsSpanOverSubstringTitle => GetResourceString("PreferAsSpanOverSubstringTitle");
/// <summary>Replace 'Substring' with 'AsSpan'</summary>
internal static string @PreferAsSpanOverSubstringCodefixTitle => GetResourceString("PreferAsSpanOverSubstringCodefixTitle");
/// <summary>'ThrowIfCancellationRequested' automatically checks whether the token has been canceled, and throws an 'OperationCanceledException' if it has.</summary>
internal static string @UseCancellationTokenThrowIfCancellationRequestedDescription => GetResourceString("UseCancellationTokenThrowIfCancellationRequestedDescription");
/// <summary>Use 'ThrowIfCancellationRequested' instead of checking 'IsCancellationRequested' and throwing 'OperationCanceledException'</summary>
internal static string @UseCancellationTokenThrowIfCancellationRequestedMessage => GetResourceString("UseCancellationTokenThrowIfCancellationRequestedMessage");
/// <summary>Use 'ThrowIfCancellationRequested'</summary>
internal static string @UseCancellationTokenThrowIfCancellationRequestedTitle => GetResourceString("UseCancellationTokenThrowIfCancellationRequestedTitle");
/// <summary>Replace with 'CancellationToken.ThrowIfCancellationRequested'</summary>
internal static string @UseCancellationTokenThrowIfCancellationRequestedCodeFixTitle => GetResourceString("UseCancellationTokenThrowIfCancellationRequestedCodeFixTitle");
/// <summary>To improve performance, override the memory-based async methods when subclassing 'Stream'. Then implement the array-based methods in terms of the memory-based methods.</summary>
internal static string @ProvideStreamMemoryBasedAsyncOverridesDescription => GetResourceString("ProvideStreamMemoryBasedAsyncOverridesDescription");
/// <summary>'{0}' overrides array-based '{1}' but does not override memory-based '{2}'. Consider overriding memory-based '{2}' to improve performance.</summary>
internal static string @ProvideStreamMemoryBasedAsyncOverridesMessage => GetResourceString("ProvideStreamMemoryBasedAsyncOverridesMessage");
/// <summary>Provide memory-based overrides of async methods when subclassing 'Stream'</summary>
internal static string @ProvideStreamMemoryBasedAsyncOverridesTitle => GetResourceString("ProvideStreamMemoryBasedAsyncOverridesTitle");
/// <summary>It is more efficient to use 'AsSpan' and 'string.Concat', instead of 'Substring' and a concatenation operator.</summary>
internal static string @UseSpanBasedStringConcatDescription => GetResourceString("UseSpanBasedStringConcatDescription");
/// <summary>Use span-based 'string.Concat' and 'AsSpan' instead of 'Substring'</summary>
internal static string @UseSpanBasedStringConcatMessage => GetResourceString("UseSpanBasedStringConcatMessage");
/// <summary>Use span-based 'string.Concat'</summary>
internal static string @UseSpanBasedStringConcatTitle => GetResourceString("UseSpanBasedStringConcatTitle");
/// <summary>Use 'AsSpan' with 'string.Concat'</summary>
internal static string @UseSpanBasedStringConcatCodeFixTitle => GetResourceString("UseSpanBasedStringConcatCodeFixTitle");
/// <summary>Use 'ContainsKey'</summary>
internal static string @PreferDictionaryContainsKeyCodeFixTitle => GetResourceString("PreferDictionaryContainsKeyCodeFixTitle");
/// <summary>'ContainsKey' is usually O(1), while 'Keys.Contains' may be O(n) in some cases. Additionally, many dictionary implementations lazily initialize the Keys collection to cut back on allocations.</summary>
internal static string @PreferDictionaryContainsKeyDescription => GetResourceString("PreferDictionaryContainsKeyDescription");
/// <summary>Prefer 'ContainsKey' over 'Keys.Contains' for dictionary type '{0}'</summary>
internal static string @PreferDictionaryContainsKeyMessage => GetResourceString("PreferDictionaryContainsKeyMessage");
/// <summary>Prefer Dictionary.Contains methods</summary>
internal static string @PreferDictionaryContainsMethodsTitle => GetResourceString("PreferDictionaryContainsMethodsTitle");
/// <summary>Use 'ContainsValue'</summary>
internal static string @PreferDictionaryContainsValueCodeFixTitle => GetResourceString("PreferDictionaryContainsValueCodeFixTitle");
/// <summary>Many dictionary implementations lazily initialize the Values collection. To avoid unnecessary allocations, prefer 'ContainsValue' over 'Values.Contains'.</summary>
internal static string @PreferDictionaryContainsValueDescription => GetResourceString("PreferDictionaryContainsValueDescription");
/// <summary>Prefer 'ContainsValue' over 'Values.Contains' for dictionary type '{0}'</summary>
internal static string @PreferDictionaryContainsValueMessage => GetResourceString("PreferDictionaryContainsValueMessage");
/// <summary>Platform compatibility analyzer requires a valid platform name and version.</summary>
internal static string @UseValidPlatformStringDescription => GetResourceString("UseValidPlatformStringDescription");
/// <summary>Use valid platform string</summary>
internal static string @UseValidPlatformStringTitle => GetResourceString("UseValidPlatformStringTitle");
/// <summary>The platform '{0}' is not a known platform name</summary>
internal static string @UseValidPlatformStringUnknownPlatform => GetResourceString("UseValidPlatformStringUnknownPlatform");
/// <summary>Version '{0}' is not valid for platform '{1}'. Use a version with 2{2} parts for this platform.</summary>
internal static string @UseValidPlatformStringInvalidVersion => GetResourceString("UseValidPlatformStringInvalidVersion");
/// <summary>Version '{0}' is not valid for platform '{1}'. Do not use versions for this platform.</summary>
internal static string @UseValidPlatformStringNoVersion => GetResourceString("UseValidPlatformStringNoVersion");
/// <summary>Using 'WaitAll' with a single task may result in performance loss, await or return the task instead.</summary>
internal static string @DoNotUseWaitAllWithSingleTaskDescription => GetResourceString("DoNotUseWaitAllWithSingleTaskDescription");
/// <summary>Do not use 'WaitAll' with a single task</summary>
internal static string @DoNotUseWaitAllWithSingleTaskTitle => GetResourceString("DoNotUseWaitAllWithSingleTaskTitle");
/// <summary>Using 'WhenAll' with a single task may result in performance loss, await or return the task instead.</summary>
internal static string @DoNotUseWhenAllWithSingleTaskDescription => GetResourceString("DoNotUseWhenAllWithSingleTaskDescription");
/// <summary>Do not use 'WhenAll' with a single task</summary>
internal static string @DoNotUseWhenAllWithSingleTaskTitle => GetResourceString("DoNotUseWhenAllWithSingleTaskTitle");
/// <summary>Replace 'WaitAll' with single 'Wait'</summary>
internal static string @DoNotUseWaitAllWithSingleTaskFix => GetResourceString("DoNotUseWaitAllWithSingleTaskFix");
/// <summary>Replace 'WhenAll' call with argument</summary>
internal static string @DoNotUseWhenAllWithSingleTaskFix => GetResourceString("DoNotUseWhenAllWithSingleTaskFix");
/// <summary>Cancel Task.Delay after Task.WhenAny completes</summary>
internal static string @DoNotUseNonCancelableTaskDelayWithWhenAnyTitle => GetResourceString("DoNotUseNonCancelableTaskDelayWithWhenAnyTitle");
/// <summary>Using Task.WhenAny with Task.Delay may result in a timer continuing to run after the operation completes, wasting resources</summary>
internal static string @DoNotUseNonCancelableTaskDelayWithWhenAnyMessage => GetResourceString("DoNotUseNonCancelableTaskDelayWithWhenAnyMessage");
/// <summary>When Task.Delay is used with Task.WhenAny to implement a timeout, the timer created by Task.Delay continues to run even after WhenAny completes, wasting resources. If your target framework supports Task.WaitAsync, use that instead as it has built-in timeou ...</summary>
internal static string @DoNotUseNonCancelableTaskDelayWithWhenAnyDescription => GetResourceString("DoNotUseNonCancelableTaskDelayWithWhenAnyDescription");
/// <summary>Use 'string.Equals'</summary>
internal static string @UseStringEqualsOverStringCompareCodeFixTitle => GetResourceString("UseStringEqualsOverStringCompareCodeFixTitle");
/// <summary>It is both clearer and likely faster to use 'string.Equals' instead of comparing the result of 'string.Compare' to zero.</summary>
internal static string @UseStringEqualsOverStringCompareDescription => GetResourceString("UseStringEqualsOverStringCompareDescription");
/// <summary>Use 'string.Equals' instead of comparing the result of 'string.Compare' to 0</summary>
internal static string @UseStringEqualsOverStringCompareMessage => GetResourceString("UseStringEqualsOverStringCompareMessage");
/// <summary>Use 'string.Equals'</summary>
internal static string @UseStringEqualsOverStringCompareTitle => GetResourceString("UseStringEqualsOverStringCompareTitle");
/// <summary>Providing a parameterless constructor that is as visible as the containing type for a type derived from 'System.Runtime.InteropServices.SafeHandle' enables better performance and usage with source-generated interop solutions.</summary>
internal static string @ProvidePublicParameterlessSafeHandleConstructorDescription => GetResourceString("ProvidePublicParameterlessSafeHandleConstructorDescription");
/// <summary>Provide a parameterless constructor that is as visible as the containing type for the '{0}' type that is derived from 'System.Runtime.InteropServices.SafeHandle'</summary>
internal static string @ProvidePublicParameterlessSafeHandleConstructorMessage => GetResourceString("ProvidePublicParameterlessSafeHandleConstructorMessage");
/// <summary>Provide a parameterless constructor that is as visible as the containing type for concrete types derived from 'System.Runtime.InteropServices.SafeHandle'</summary>
internal static string @ProvidePublicParameterlessSafeHandleConstructorTitle => GetResourceString("ProvidePublicParameterlessSafeHandleConstructorTitle");
/// <summary>Make the constructor that takes zero parameters 'public'</summary>
internal static string @MakeParameterlessConstructorPublic => GetResourceString("MakeParameterlessConstructorPublic");
/// <summary>Providing a functional 'DynamicInterfaceCastableImplementationAttribute'-attributed interface requires the Default Interface Members feature, which is unsupported in Visual Basic.</summary>
internal static string @DynamicInterfaceCastableImplementationUnsupportedDescription => GetResourceString("DynamicInterfaceCastableImplementationUnsupportedDescription");
/// <summary>Providing a 'DynamicInterfaceCastableImplementation' interface in Visual Basic is unsupported</summary>
internal static string @DynamicInterfaceCastableImplementationUnsupportedMessage => GetResourceString("DynamicInterfaceCastableImplementationUnsupportedMessage");
/// <summary>Providing a 'DynamicInterfaceCastableImplementation' interface in Visual Basic is unsupported</summary>
internal static string @DynamicInterfaceCastableImplementationUnsupportedTitle => GetResourceString("DynamicInterfaceCastableImplementationUnsupportedTitle");
/// <summary>Implement inherited interfaces</summary>
internal static string @ImplementInterfacesOnDynamicCastableImplementation => GetResourceString("ImplementInterfacesOnDynamicCastableImplementation");
/// <summary>Types attributed with 'DynamicInterfaceCastableImplementationAttribute' act as an interface implementation for a type that implements the 'IDynamicInterfaceCastable' type. As a result, it must provide an implementation of all of the members defined in the ...</summary>
internal static string @InterfaceMembersMissingImplementationDescription => GetResourceString("InterfaceMembersMissingImplementationDescription");
/// <summary>Type '{0}' has the 'DynamicInterfaceCastableImplementationAttribute' applied to it but does not provide an implementation of all interface members defined in inherited interfaces</summary>
internal static string @InterfaceMembersMissingImplementationMessage => GetResourceString("InterfaceMembersMissingImplementationMessage");
/// <summary>All members declared in parent interfaces must have an implementation in a DynamicInterfaceCastableImplementation-attributed interface</summary>
internal static string @InterfaceMembersMissingImplementationTitle => GetResourceString("InterfaceMembersMissingImplementationTitle");
/// <summary>Since a type that implements 'IDynamicInterfaceCastable' may not implement a dynamic interface in metadata, calls to an instance interface member that is not an explicit implementation defined on this type are likely to fail at runtime. Mark new interface ...</summary>
internal static string @MembersDeclaredOnImplementationTypeMustBeStaticDescription => GetResourceString("MembersDeclaredOnImplementationTypeMustBeStaticDescription");
/// <summary>The '{0}' member on the '{1}' type should be marked 'static' as '{1}' has the 'DynamicInterfaceImplementationAttribute' applied</summary>
internal static string @MembersDeclaredOnImplementationTypeMustBeStaticMessage => GetResourceString("MembersDeclaredOnImplementationTypeMustBeStaticMessage");
/// <summary>Members defined on an interface with the 'DynamicInterfaceCastableImplementationAttribute' should be 'static'</summary>
internal static string @MembersDeclaredOnImplementationTypeMustBeStaticTitle => GetResourceString("MembersDeclaredOnImplementationTypeMustBeStaticTitle");
/// <summary>Convert to static method</summary>
internal static string @MakeMethodDeclaredOnImplementationTypeStatic => GetResourceString("MakeMethodDeclaredOnImplementationTypeStatic");
/// <summary>'string.Contains(char)' is available as a better performing overload for single char lookup.</summary>
internal static string @UseStringContainsCharOverloadWithSingleCharactersDescription => GetResourceString("UseStringContainsCharOverloadWithSingleCharactersDescription");
/// <summary>Use 'string.Contains(char)' instead of 'string.Contains(string)' when searching for a single character</summary>
internal static string @UseStringContainsCharOverloadWithSingleCharactersMessage => GetResourceString("UseStringContainsCharOverloadWithSingleCharactersMessage");
/// <summary>Use char literal for a single character lookup</summary>
internal static string @UseStringContainsCharOverloadWithSingleCharactersTitle => GetResourceString("UseStringContainsCharOverloadWithSingleCharactersTitle");
/// <summary>Replace string literal with char literal</summary>
internal static string @ReplaceStringLiteralWithCharLiteralCodeActionTitle => GetResourceString("ReplaceStringLiteralWithCharLiteralCodeActionTitle");
/// <summary>Prefer static 'HashData' method over 'ComputeHash'</summary>
internal static string @PreferHashDataOverComputeHashAnalyzerTitle => GetResourceString("PreferHashDataOverComputeHashAnalyzerTitle");
/// <summary>It is more efficient to use the static 'HashData' method over creating and managing a HashAlgorithm instance to call 'ComputeHash'.</summary>
internal static string @PreferHashDataOverComputeHashAnalyzerDescription => GetResourceString("PreferHashDataOverComputeHashAnalyzerDescription");
/// <summary>Prefer static '{0}.HashData' method over 'ComputeHash'</summary>
internal static string @PreferHashDataOverComputeHashAnalyzerMessage => GetResourceString("PreferHashDataOverComputeHashAnalyzerMessage");
/// <summary>Replace with 'HashData' method</summary>
internal static string @PreferHashDataCodefixTitle => GetResourceString("PreferHashDataCodefixTitle");
/// <summary>An assembly has to opt into preview features before using them.</summary>
internal static string @DetectPreviewFeaturesDescription => GetResourceString("DetectPreviewFeaturesDescription");
/// <summary>{2} Using '{0}' requires opting into preview features. See {1} for more information.</summary>
internal static string @DetectPreviewFeaturesMessageWithCustomMessagePlaceholder => GetResourceString("DetectPreviewFeaturesMessageWithCustomMessagePlaceholder");
/// <summary>This API requires opting into preview features</summary>
internal static string @DetectPreviewFeaturesTitle => GetResourceString("DetectPreviewFeaturesTitle");
/// <summary>Using both 'static' and 'abstract' modifiers requires opting into preview features. See https://aka.ms/dotnet-warnings/preview-features for more information.</summary>
internal static string @StaticAndAbstractRequiresPreviewFeatures => GetResourceString("StaticAndAbstractRequiresPreviewFeatures");
/// <summary>Converting an instance method to a static method may produce invalid code</summary>
internal static string @MakeMethodDeclaredOnImplementationTypeStaticMayProduceInvalidCode => GetResourceString("MakeMethodDeclaredOnImplementationTypeStaticMayProduceInvalidCode");
/// <summary>{3} '{0}' derives from preview class '{1}' and therefore needs to opt into preview features. See {2} for more information.</summary>
internal static string @DerivesFromPreviewClassMessageWithCustomMessagePlaceholder => GetResourceString("DerivesFromPreviewClassMessageWithCustomMessagePlaceholder");
/// <summary>{3} '{0}' implements the preview interface '{1}' and therefore needs to opt into preview features. See {2} for more information.</summary>
internal static string @ImplementsPreviewInterfaceMessageWithCustomMessagePlaceholder => GetResourceString("ImplementsPreviewInterfaceMessageWithCustomMessagePlaceholder");
/// <summary>{3} '{0}' implements the preview method '{1}' and therefore needs to opt into preview features. See {2} for more information.</summary>
internal static string @ImplementsPreviewMethodMessageWithCustomMessagePlaceholder => GetResourceString("ImplementsPreviewMethodMessageWithCustomMessagePlaceholder");
/// <summary>{3} '{0}' returns the preview type '{1}' and therefore needs to opt into preview features. See {2} for more information.</summary>
internal static string @MethodReturnsPreviewTypeMessageWithCustomMessagePlaceholder => GetResourceString("MethodReturnsPreviewTypeMessageWithCustomMessagePlaceholder");
/// <summary>{3} '{0}' takes in a preview parameter of type '{1}' and needs to opt into preview features. See {2} for more information.</summary>
internal static string @MethodUsesPreviewTypeAsParameterMessageWithCustomMessagePlaceholder => GetResourceString("MethodUsesPreviewTypeAsParameterMessageWithCustomMessagePlaceholder");
/// <summary>{3} '{0}' overrides the preview method '{1}' and therefore needs to opt into preview features. See {2} for more information.</summary>
internal static string @OverridesPreviewMethodMessageWithCustomMessagePlaceholder => GetResourceString("OverridesPreviewMethodMessageWithCustomMessagePlaceholder");
/// <summary>{3} '{0}' uses the preview type '{1}' and needs to opt into preview features. See {2} for more information.</summary>
internal static string @UsesPreviewTypeParameterMessageWithCustomMessagePlaceholder => GetResourceString("UsesPreviewTypeParameterMessageWithCustomMessagePlaceholder");
/// <summary>{3} '{0}''s type contains the preview type '{1}' and requires opting into preview features. See {2} for more information.</summary>
internal static string @FieldIsPreviewTypeMessageWithCustomMessagePlaceholder => GetResourceString("FieldIsPreviewTypeMessageWithCustomMessagePlaceholder");
/// <summary>Module initializers are intended to be used by application code to ensure an application's components are initialized before the application code begins executing. If library code declares a method with the 'ModuleInitializerAttribute', it can interfere wi ...</summary>
internal static string @ModuleInitializerAttributeShouldNotBeUsedInLibrariesDescription => GetResourceString("ModuleInitializerAttributeShouldNotBeUsedInLibrariesDescription");
/// <summary>The 'ModuleInitializer' attribute is only intended to be used in application code or advanced source generator scenarios</summary>
internal static string @ModuleInitializerAttributeShouldNotBeUsedInLibrariesMessage => GetResourceString("ModuleInitializerAttributeShouldNotBeUsedInLibrariesMessage");
/// <summary>The 'ModuleInitializer' attribute should not be used in libraries</summary>
internal static string @ModuleInitializerAttributeShouldNotBeUsedInLibrariesTitle => GetResourceString("ModuleInitializerAttributeShouldNotBeUsedInLibrariesTitle");
/// <summary>Enumerable.Cast<T> and Enumerable.OfType<T> require compatible types to function expectedly.
/// The generic cast (IL 'unbox.any') used by the sequence returned by Enumerable.Cast<T> will throw InvalidCastException at runtime on elements of the types specifi ...</summary>
internal static string @DoNotCallEnumerableCastOrOfTypeWithIncompatibleTypesDescription => GetResourceString("DoNotCallEnumerableCastOrOfTypeWithIncompatibleTypesDescription");
/// <summary>Type '{0}' is incompatible with type '{1}' and cast attempts will throw InvalidCastException at runtime</summary>
internal static string @DoNotCallEnumerableCastOrOfTypeWithIncompatibleTypesMessageCast => GetResourceString("DoNotCallEnumerableCastOrOfTypeWithIncompatibleTypesMessageCast");
/// <summary>'{0}' synchronously blocks. Await '{1}' instead.</summary>
internal static string @UseAsyncMethodInAsyncContextMessage => GetResourceString("UseAsyncMethodInAsyncContextMessage");
/// <summary>Call async methods when in an async method</summary>
internal static string @UseAsyncMethodInAsyncContextTitle => GetResourceString("UseAsyncMethodInAsyncContextTitle");
/// <summary>'{0}' synchronously blocks. Use await instead.</summary>
internal static string @UseAsyncMethodInAsyncContextMessage_NoAlternative => GetResourceString("UseAsyncMethodInAsyncContextMessage_NoAlternative");
/// <summary>When inside a Task-returning method, use the async version of methods, if they exist.</summary>
internal static string @UseAsyncMethodInAsyncContextDescription => GetResourceString("UseAsyncMethodInAsyncContextDescription");
/// <summary>Do not disable token validation checks</summary>
internal static string @DoNotDisableTokenValidationChecksTitle => GetResourceString("DoNotDisableTokenValidationChecksTitle");
/// <summary>Token validation checks ensure that while validating tokens, all aspects are analyzed and verified. Turning off validation can lead to security holes by allowing untrusted tokens to make it through validation.</summary>
internal static string @DoNotDisableTokenValidationChecksDescription => GetResourceString("DoNotDisableTokenValidationChecksDescription");
/// <summary>TokenValidationParameters.{0} should not be set to false as it disables important validation</summary>
internal static string @DoNotDisableTokenValidationChecksMessage => GetResourceString("DoNotDisableTokenValidationChecksMessage");
/// <summary>Do not always skip token validation in delegates</summary>
internal static string @DoNotAlwaysSkipTokenValidationInDelegatesTitle => GetResourceString("DoNotAlwaysSkipTokenValidationInDelegatesTitle");
/// <summary>By setting critical TokenValidationParameter validation delegates to true, important authentication safeguards are disabled which can lead to tokens from any issuer or expired tokens being wrongly validated.</summary>
internal static string @DoNotAlwaysSkipTokenValidationInDelegatesDescription => GetResourceString("DoNotAlwaysSkipTokenValidationInDelegatesDescription");
/// <summary>The {0} is set to a function that is always returning true. By setting the validation delegate, you are overriding default validation and by always returning true, this validation is completely disabled.</summary>
internal static string @DoNotAlwaysSkipTokenValidationInDelegatesMessage => GetResourceString("DoNotAlwaysSkipTokenValidationInDelegatesMessage");
/// <summary>'{0}' derives from preview class '{1}' and therefore needs to opt into preview features. See {2} for more information.</summary>
internal static string @DerivesFromPreviewClassMessage => GetResourceString("DerivesFromPreviewClassMessage");
/// <summary>Using '{0}' requires opting into preview features. See {1} for more information.</summary>
internal static string @DetectPreviewFeaturesMessage => GetResourceString("DetectPreviewFeaturesMessage");
/// <summary>'{0}''s type contains the preview type '{1}' and requires opting into preview features. See {2} for more information.</summary>
internal static string @FieldIsPreviewTypeMessage => GetResourceString("FieldIsPreviewTypeMessage");
/// <summary>'{0}' implements the preview interface '{1}' and therefore needs to opt into preview features. See {2} for more information.</summary>
internal static string @ImplementsPreviewInterfaceMessage => GetResourceString("ImplementsPreviewInterfaceMessage");
/// <summary>'{0}' implements the preview method '{1}' and therefore needs to opt into preview features. See {2} for more information.</summary>
internal static string @ImplementsPreviewMethodMessage => GetResourceString("ImplementsPreviewMethodMessage");
/// <summary>'{0}' returns the preview type '{1}' and therefore needs to opt into preview features. See {2} for more information.</summary>
internal static string @MethodReturnsPreviewTypeMessage => GetResourceString("MethodReturnsPreviewTypeMessage");
/// <summary>'{0}' takes in a preview parameter of type '{1}' and needs to opt into preview features. See {2} for more information.</summary>
internal static string @MethodUsesPreviewTypeAsParameterMessage => GetResourceString("MethodUsesPreviewTypeAsParameterMessage");
/// <summary>'{0}' overrides the preview method '{1}' and therefore needs to opt into preview features. See {2} for more information.</summary>
internal static string @OverridesPreviewMethodMessage => GetResourceString("OverridesPreviewMethodMessage");
/// <summary>'{0}' uses the preview type '{1}' and needs to opt into preview features. See {2} for more information.</summary>
internal static string @UsesPreviewTypeParameterMessage => GetResourceString("UsesPreviewTypeParameterMessage");
/// <summary>Incorrect usage of ConstantExpected attribute</summary>
internal static string @ConstantExpectedApplicationTitle => GetResourceString("ConstantExpectedApplicationTitle");
/// <summary>ConstantExpected attribute is not applied correctly on the parameter.</summary>
internal static string @ConstantExpectedApplicationDescription => GetResourceString("ConstantExpectedApplicationDescription");
/// <summary>A constant is expected for the parameter</summary>
internal static string @ConstantExpectedUsageTitle => GetResourceString("ConstantExpectedUsageTitle");
/// <summary>The parameter expects a constant for optimal performance.</summary>
internal static string @ConstantExpectedUsageDescription => GetResourceString("ConstantExpectedUsageDescription");
/// <summary>The '{0}' type is not supported for ConstantExpected attribute</summary>
internal static string @ConstantExpectedNotSupportedMessage => GetResourceString("ConstantExpectedNotSupportedMessage");
/// <summary>The '{0}' value is not compatible with parameter type of '{1}'</summary>
internal static string @ConstantExpectedIncompatibleConstantTypeMessage => GetResourceString("ConstantExpectedIncompatibleConstantTypeMessage");
/// <summary>The '{0}' value does not fit within the parameter value bounds of '{1}' to '{2}'</summary>
internal static string @ConstantExpectedInvalidBoundsMessage => GetResourceString("ConstantExpectedInvalidBoundsMessage");
/// <summary>The Min and Max values are inverted</summary>
internal static string @ConstantExpectedInvertedRangeMessage => GetResourceString("ConstantExpectedInvertedRangeMessage");
/// <summary>The constant does not fit within the value bounds of '{0}' to '{1}'</summary>
internal static string @ConstantExpectedOutOfBoundsMessage => GetResourceString("ConstantExpectedOutOfBoundsMessage");
/// <summary>The constant is not of the same '{0}' type as the parameter</summary>
internal static string @ConstantExpectedInvalidMessage => GetResourceString("ConstantExpectedInvalidMessage");
/// <summary>The argument should be a constant for optimal performance</summary>
internal static string @ConstantExpectedNotConstantMessage => GetResourceString("ConstantExpectedNotConstantMessage");
/// <summary>The ConstantExpected attribute is required for the parameter due to the parent method annotation</summary>
internal static string @ConstantExpectedAttributExpectedMessage => GetResourceString("ConstantExpectedAttributExpectedMessage");
/// <summary>Specify a culture or use an invariant version</summary>
internal static string @SpecifyCultureForToLowerAndToUpperTitle => GetResourceString("SpecifyCultureForToLowerAndToUpperTitle");
/// <summary>Specify culture to help avoid accidental implicit dependency on current culture. Using an invariant version yields consistent results regardless of the culture of an application.</summary>
internal static string @SpecifyCultureForToLowerAndToUpperDescription => GetResourceString("SpecifyCultureForToLowerAndToUpperDescription");
/// <summary>Specify a culture or use an invariant version to avoid implicit dependency on current culture</summary>
internal static string @SpecifyCultureForToLowerAndToUpperMessage => GetResourceString("SpecifyCultureForToLowerAndToUpperMessage");
/// <summary>Specify current culture</summary>
internal static string @SpecifyCurrentCulture => GetResourceString("SpecifyCurrentCulture");
/// <summary>Use an invariant version</summary>
internal static string @UseInvariantVersion => GetResourceString("UseInvariantVersion");
/// <summary>Using features that require runtime marshalling when runtime marshalling is disabled will result in runtime exceptions.</summary>
internal static string @FeatureUnsupportedWhenRuntimeMarshallingDisabledDescription => GetResourceString("FeatureUnsupportedWhenRuntimeMarshallingDisabledDescription");
/// <summary>Property, type, or attribute requires runtime marshalling</summary>
internal static string @FeatureUnsupportedWhenRuntimeMarshallingDisabledTitle => GetResourceString("FeatureUnsupportedWhenRuntimeMarshallingDisabledTitle");
/// <summary>This method uses runtime marshalling even when runtime marshalling is disabled, which can cause unexpected behavior differences at runtime due to different expectations of a type's native layout.</summary>
internal static string @MethodUsesRuntimeMarshallingEvenWhenMarshallingDisabledDescription => GetResourceString("MethodUsesRuntimeMarshallingEvenWhenMarshallingDisabledDescription");
/// <summary>'{0}' uses runtime marshalling even when 'DisableRuntimeMarshallingAttribute' is applied. Use features like 'sizeof' and pointers directly to ensure accurate results.</summary>
internal static string @MethodUsesRuntimeMarshallingEvenWhenMarshallingDisabledMessage => GetResourceString("MethodUsesRuntimeMarshallingEvenWhenMarshallingDisabledMessage");
/// <summary>This method uses runtime marshalling even when the 'DisableRuntimeMarshallingAttribute' is applied</summary>
internal static string @MethodUsesRuntimeMarshallingEvenWhenMarshallingDisabledTitle => GetResourceString("MethodUsesRuntimeMarshallingEvenWhenMarshallingDisabledTitle");
/// <summary>Use equivalent code that works when marshalling is disabled</summary>
internal static string @UseDisabledMarshallingEquivalentCodeFix => GetResourceString("UseDisabledMarshallingEquivalentCodeFix");
/// <summary>Types with '[StructLayout(LayoutKind.Auto)]' require runtime marshalling to be enabled</summary>
internal static string @FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageAutoLayoutTypes => GetResourceString("FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageAutoLayoutTypes");
/// <summary>By-ref parameters require runtime marshalling to be enabled</summary>
internal static string @FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageByRefParameters => GetResourceString("FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageByRefParameters");
/// <summary>HResult-swapping requires runtime marshalling to be enabled</summary>
internal static string @FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageHResultSwapping => GetResourceString("FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageHResultSwapping");
/// <summary>Using 'LCIDConversionAttribute' requires runtime marshalling to be enabled</summary>
internal static string @FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageLCIDConversionAttribute => GetResourceString("FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageLCIDConversionAttribute");
/// <summary>Managed parameter or return types require runtime marshalling to be enabled</summary>
internal static string @FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageManagedParameterOrReturnTypes => GetResourceString("FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageManagedParameterOrReturnTypes");
/// <summary>Setting SetLastError to 'true' requires runtime marshalling to be enabled</summary>
internal static string @FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageSetLastError => GetResourceString("FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageSetLastError");
/// <summary>Varadic P/Invoke signatures require runtime marshalling to be enabled</summary>
internal static string @FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageVarargPInvokes => GetResourceString("FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageVarargPInvokes");
/// <summary>When a type is not accessible outside its assembly and has no subtypes within its containing assembly, it can be safely sealed. Sealing types can improve performance.</summary>
internal static string @SealInternalTypesDescription => GetResourceString("SealInternalTypesDescription");
/// <summary>Type '{0}' can be sealed because it has no subtypes in its containing assembly and is not externally visible</summary>
internal static string @SealInternalTypesMessage => GetResourceString("SealInternalTypesMessage");
/// <summary>Seal internal types</summary>
internal static string @SealInternalTypesTitle => GetResourceString("SealInternalTypesTitle");
/// <summary>Seal class</summary>
internal static string @SealInternalTypesCodeFixTitle => GetResourceString("SealInternalTypesCodeFixTitle");
/// <summary>Delegates with managed types as parameters or the return type require runtime marshalling to be enabled in the assembly where the delegate is defined</summary>
internal static string @FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageDelegateUsage => GetResourceString("FeatureUnsupportedWhenRuntimeMarshallingDisabledMessageDelegateUsage");
/// <summary>Use 'TryGetValue(TKey, out TValue)'</summary>
internal static string @PreferDictionaryTryGetValueCodeFixTitle => GetResourceString("PreferDictionaryTryGetValueCodeFixTitle");
/// <summary>Prefer the 'IDictionary.TryGetValue(TKey, out TValue)' method</summary>
internal static string @PreferDictionaryTryGetValueTitle => GetResourceString("PreferDictionaryTryGetValueTitle");
/// <summary>Prefer a 'TryGetValue' call over a Dictionary indexer access guarded by a 'ContainsKey' check to avoid double lookup</summary>
internal static string @PreferDictionaryTryGetValueMessage => GetResourceString("PreferDictionaryTryGetValueMessage");
/// <summary>Prefer a 'TryGetValue' call over a Dictionary indexer access guarded by a 'ContainsKey' check. 'ContainsKey' and the indexer both would lookup the key under the hood, so using 'TryGetValue' removes the extra lookup.</summary>
internal static string @PreferDictionaryTryGetValueDescription => GetResourceString("PreferDictionaryTryGetValueDescription");
/// <summary>The behavior of '{0}' could vary based on the current user's locale settings. Provide a value for the 'IFormatProvider' argument.</summary>
internal static string @SpecifyIFormatProviderMessageIFormatProviderOptional => GetResourceString("SpecifyIFormatProviderMessageIFormatProviderOptional");
/// <summary>This call site is reachable on all platforms. '{0}' is obsoleted on: {1}.</summary>
internal static string @PlatformCompatibilityObsoletedCsAllPlatformMessage => GetResourceString("PlatformCompatibilityObsoletedCsAllPlatformMessage");
/// <summary>This call site is reachable on: {2}. '{0}' is obsoleted on: {1}.</summary>
internal static string @PlatformCompatibilityObsoletedCsReachableMessage => GetResourceString("PlatformCompatibilityObsoletedCsReachableMessage");
/// <summary>({0})</summary>
internal static string @ParenthesisWithPlaceHolder => GetResourceString("ParenthesisWithPlaceHolder");
/// <summary>Generic math interfaces require the derived type itself to be used for the self recurring type parameter.</summary>
internal static string @ImplementGenericMathInterfacesCorrectlyDescription => GetResourceString("ImplementGenericMathInterfacesCorrectlyDescription");
/// <summary>The '{0}' requires the '{1}' type parameter to be filled with the derived type '{2}'</summary>
internal static string @ImplementGenericMathInterfacesCorrectlyMessage => GetResourceString("ImplementGenericMathInterfacesCorrectlyMessage");
/// <summary>Use correct type parameter</summary>
internal static string @ImplementGenericMathInterfacesCorrectlyTitle => GetResourceString("ImplementGenericMathInterfacesCorrectlyTitle");
/// <summary>Use generic overload</summary>
internal static string @PreferGenericOverloadsCodeFixTitle => GetResourceString("PreferGenericOverloadsCodeFixTitle");
/// <summary>Using a generic overload is preferable to the 'System.Type' overload when the type is known, promoting cleaner and more type-safe code with improved compile-time checks.</summary>
internal static string @PreferGenericOverloadsDescription => GetResourceString("PreferGenericOverloadsDescription");
/// <summary>Prefer the generic overload '{0}' instead of '{1}'</summary>
internal static string @PreferGenericOverloadsMessage => GetResourceString("PreferGenericOverloadsMessage");
/// <summary>Prefer generic overload when type is known</summary>
internal static string @PreferGenericOverloadsTitle => GetResourceString("PreferGenericOverloadsTitle");
/// <summary>Use 'Clear()'</summary>
internal static string @UseSpanClearInsteadOfFillCodeFixTitle => GetResourceString("UseSpanClearInsteadOfFillCodeFixTitle");
/// <summary>It is more efficient to use 'Clear', instead of 'Fill' with default value.</summary>
internal static string @UseSpanClearInsteadOfFillDescription => GetResourceString("UseSpanClearInsteadOfFillDescription");
/// <summary>Prefer 'Span<T>.Clear()' instead of 'Span<T>.Fill(default)'</summary>
internal static string @UseSpanClearInsteadOfFillMessage => GetResourceString("UseSpanClearInsteadOfFillMessage");
/// <summary>Prefer 'Clear' over 'Fill'</summary>
internal static string @UseSpanClearInsteadOfFillTitle => GetResourceString("UseSpanClearInsteadOfFillTitle");
/// <summary>Use a cached 'SearchValues' instance</summary>
internal static string @UseSearchValuesTitle => GetResourceString("UseSearchValuesTitle");
/// <summary>Use a cached 'SearchValues' instance for improved searching performance</summary>
internal static string @UseSearchValuesMessage => GetResourceString("UseSearchValuesMessage");
/// <summary>Using a cached 'SearchValues' instance is more efficient than passing values to 'IndexOfAny'/'ContainsAny' directly.</summary>
internal static string @UseSearchValuesDescription => GetResourceString("UseSearchValuesDescription");
/// <summary>Use 'SearchValues'</summary>
internal static string @UseSearchValuesCodeFixTitle => GetResourceString("UseSearchValuesCodeFixTitle");
/// <summary>Some built-in operators added in .NET 7 behave differently when overflowing than did the corresponding user-defined operators in .NET 6 and earlier versions. Some operators that previously threw in an unchecked context now don't throw unless wrapped within ...</summary>
internal static string @PreventNumericIntPtrUIntPtrBehavioralChangesDescription => GetResourceString("PreventNumericIntPtrUIntPtrBehavioralChangesDescription");
/// <summary>Starting with .NET 7 the explicit conversion '{0}' will not throw when overflowing in an unchecked context. Wrap the expression with a 'checked' statement to restore the .NET 6 behavior.</summary>
internal static string @PreventNumericIntPtrUIntPtrBehavioralChangesConversionNotThrowMessage => GetResourceString("PreventNumericIntPtrUIntPtrBehavioralChangesConversionNotThrowMessage");
/// <summary>Starting with .NET 7 the operator '{0}' will throw when overflowing in a checked context. Wrap the expression with an 'unchecked' statement to restore the .NET 6 behavior.</summary>
internal static string @PreventNumericIntPtrUIntPtrBehavioralChangesOperatorThrowsMessage => GetResourceString("PreventNumericIntPtrUIntPtrBehavioralChangesOperatorThrowsMessage");
/// <summary>Prevent behavioral change</summary>
internal static string @PreventNumericIntPtrUIntPtrBehavioralChangesTitle => GetResourceString("PreventNumericIntPtrUIntPtrBehavioralChangesTitle");
/// <summary>Starting with .NET 7 the explicit conversion '{0}' will throw when overflowing in a checked context. Wrap the expression with an 'unchecked' statement to restore the .NET 6 behavior.</summary>
internal static string @PreventNumericIntPtrUIntPtrBehavioralChangesConversionThrowsMessage => GetResourceString("PreventNumericIntPtrUIntPtrBehavioralChangesConversionThrowsMessage");
/// <summary>Use 'StartsWith'</summary>
internal static string @UseStartsWithInsteadOfIndexOfComparisonWithZeroCodeFixTitle => GetResourceString("UseStartsWithInsteadOfIndexOfComparisonWithZeroCodeFixTitle");
/// <summary>It is both clearer and faster to use 'StartsWith' instead of comparing the result of 'IndexOf' to zero.</summary>
internal static string @UseStartsWithInsteadOfIndexOfComparisonWithZeroDescription => GetResourceString("UseStartsWithInsteadOfIndexOfComparisonWithZeroDescription");
/// <summary>Use 'StartsWith' instead of comparing the result of 'IndexOf' to 0</summary>
internal static string @UseStartsWithInsteadOfIndexOfComparisonWithZeroMessage => GetResourceString("UseStartsWithInsteadOfIndexOfComparisonWithZeroMessage");
/// <summary>Use 'StartsWith' instead of 'IndexOf'</summary>
internal static string @UseStartsWithInsteadOfIndexOfComparisonWithZeroTitle => GetResourceString("UseStartsWithInsteadOfIndexOfComparisonWithZeroTitle");
/// <summary>Use ArgumentNullException throw helper</summary>
internal static string @UseArgumentNullExceptionThrowHelperTitle => GetResourceString("UseArgumentNullExceptionThrowHelperTitle");
/// <summary>Use ArgumentException throw helper</summary>
internal static string @UseArgumentExceptionThrowHelperTitle => GetResourceString("UseArgumentExceptionThrowHelperTitle");
/// <summary>Use ArgumentOutOfRangeException throw helper</summary>
internal static string @UseArgumentOutOfRangeExceptionThrowHelperTitle => GetResourceString("UseArgumentOutOfRangeExceptionThrowHelperTitle");
/// <summary>Use ObjectDisposedException throw helper</summary>
internal static string @UseObjectDisposedExceptionThrowHelperTitle => GetResourceString("UseObjectDisposedExceptionThrowHelperTitle");
/// <summary>Use '{0}.{1}' instead of explicitly throwing a new exception instance</summary>
internal static string @UseThrowHelperMessage => GetResourceString("UseThrowHelperMessage");
/// <summary>Throw helpers are simpler and more efficient than an if block constructing a new exception instance.</summary>
internal static string @UseThrowHelperDescription => GetResourceString("UseThrowHelperDescription");
/// <summary>Use '{0}.{1}'</summary>
internal static string @UseThrowHelperFix => GetResourceString("UseThrowHelperFix");
/// <summary>Prefer JsonElement.Parse over JsonDocument.Parse().RootElement</summary>
internal static string @PreferJsonElementParseTitle => GetResourceString("PreferJsonElementParseTitle");
/// <summary>Use 'JsonElement.Parse' instead of 'JsonDocument.Parse(...).RootElement' to avoid resource leaks</summary>
internal static string @PreferJsonElementParseMessage => GetResourceString("PreferJsonElementParseMessage");
/// <summary>JsonDocument implements IDisposable and needs to be properly disposed. When only the RootElement is needed, prefer JsonElement.Parse which doesn't require disposal.</summary>
internal static string @PreferJsonElementParseDescription => GetResourceString("PreferJsonElementParseDescription");
/// <summary>Use 'JsonElement.Parse'</summary>
internal static string @PreferJsonElementParseFix => GetResourceString("PreferJsonElementParseFix");
/// <summary>Avoid redundant 'Regex.IsMatch' call before 'Regex.Match'</summary>
internal static string @AvoidRedundantRegexIsMatchBeforeMatchTitle => GetResourceString("AvoidRedundantRegexIsMatchBeforeMatchTitle");
/// <summary>Redundant call to 'Regex.IsMatch' before 'Regex.Match'. Use 'Regex.Match' and check 'Match.Success' instead.</summary>
internal static string @AvoidRedundantRegexIsMatchBeforeMatchMessage => GetResourceString("AvoidRedundantRegexIsMatchBeforeMatchMessage");
/// <summary>When 'Regex.IsMatch' is used to check for a match and then 'Regex.Match' is called with the same arguments, the regular expression is evaluated twice. Call 'Regex.Match' once and check 'Match.Success' to avoid redundant work.</summary>
internal static string @AvoidRedundantRegexIsMatchBeforeMatchDescription => GetResourceString("AvoidRedundantRegexIsMatchBeforeMatchDescription");
/// <summary>Use 'Regex.Match' and check 'Success'</summary>
internal static string @AvoidRedundantRegexIsMatchBeforeMatchFix => GetResourceString("AvoidRedundantRegexIsMatchBeforeMatchFix");
/// <summary>Using concrete types avoids virtual or interface call overhead and enables inlining.</summary>
internal static string @UseConcreteTypeDescription => GetResourceString("UseConcreteTypeDescription");
/// <summary>Change type of field '{0}' from '{1}' to '{2}' for improved performance</summary>
internal static string @UseConcreteTypeForFieldMessage => GetResourceString("UseConcreteTypeForFieldMessage");
/// <summary>Use concrete types when possible for improved performance</summary>
internal static string @UseConcreteTypeTitle => GetResourceString("UseConcreteTypeTitle");
/// <summary>Change type of variable '{0}' from '{1}' to '{2}' for improved performance</summary>
internal static string @UseConcreteTypeForLocalMessage => GetResourceString("UseConcreteTypeForLocalMessage");
/// <summary>Change return type of method '{0}' from '{1}' to '{2}' for improved performance</summary>
internal static string @UseConcreteTypeForMethodReturnMessage => GetResourceString("UseConcreteTypeForMethodReturnMessage");
/// <summary>Change type of property '{0}' from '{1}' to '{2}' for improved performance</summary>
internal static string @UseConcreteTypeForPropertyMessage => GetResourceString("UseConcreteTypeForPropertyMessage");
/// <summary>Change type of parameter '{0}' from '{1}' to '{2}' for improved performance</summary>
internal static string @UseConcreteTypeForParameterMessage => GetResourceString("UseConcreteTypeForParameterMessage");
/// <summary>Use 'Length' check instead of 'Any()'</summary>
internal static string @PreferLengthOverAnyCodeFixTitle => GetResourceString("PreferLengthOverAnyCodeFixTitle");
/// <summary>Prefer comparing 'Length' to 0 rather than using 'Any()', both for clarity and for performance</summary>
internal static string @PreferLengthOverAnyMessage => GetResourceString("PreferLengthOverAnyMessage");
/// <summary>Use 'Count' check instead of 'Any()'</summary>
internal static string @PreferCountOverAnyCodeFixTitle => GetResourceString("PreferCountOverAnyCodeFixTitle");
/// <summary>Avoid using 'Enumerable.Any()' extension method</summary>
internal static string @PreferLengthCountIsEmptyOverAnyTitle => GetResourceString("PreferLengthCountIsEmptyOverAnyTitle");
/// <summary>Prefer comparing 'Count' to 0 rather than using 'Any()', both for clarity and for performance</summary>
internal static string @PreferCountOverAnyMessage => GetResourceString("PreferCountOverAnyMessage");
/// <summary>Prefer using 'IsEmpty', 'Count' or 'Length' properties whichever available, rather than calling 'Enumerable.Any()'. The intent is clearer and it is more performant than using 'Enumerable.Any()' extension method.</summary>
internal static string @PreferLengthCountIsEmptyOverAnyDescription => GetResourceString("PreferLengthCountIsEmptyOverAnyDescription");
/// <summary>Use 'IsEmpty' check instead of 'Any()'</summary>
internal static string @PreferIsEmptyOverAnyCodeFixTitle => GetResourceString("PreferIsEmptyOverAnyCodeFixTitle");
/// <summary>Prefer an 'IsEmpty' check rather than using 'Any()', both for clarity and for performance</summary>
internal static string @PreferIsEmptyOverAnyMessage => GetResourceString("PreferIsEmptyOverAnyMessage");
/// <summary>Use the 'string.{0}(string, StringComparison)' overload</summary>
internal static string @RecommendCaseInsensitiveStringComparerStringComparisonCodeFixTitle => GetResourceString("RecommendCaseInsensitiveStringComparerStringComparisonCodeFixTitle");
/// <summary>Avoid calling 'ToLower', 'ToUpper', 'ToLowerInvariant' and 'ToUpperInvariant' to perform case-insensitive string comparisons when using 'CompareTo', because they lead to an allocation. Instead, use 'StringComparer' to perform case-insensitive comparisons. ...</summary>
internal static string @RecommendCaseInsensitiveStringComparerDescription => GetResourceString("RecommendCaseInsensitiveStringComparerDescription");
/// <summary>Prefer using 'StringComparer' to perform a case-insensitive comparison, but keep in mind that this might cause subtle changes in behavior, so make sure to conduct thorough testing after applying the suggestion, or if culturally sensitive comparison is not ...</summary>
internal static string @RecommendCaseInsensitiveStringComparerMessage => GetResourceString("RecommendCaseInsensitiveStringComparerMessage");
/// <summary>Use 'string.Equals(string, StringComparison)'</summary>
internal static string @RecommendCaseInsensitiveStringEqualsCodeFixTitle => GetResourceString("RecommendCaseInsensitiveStringEqualsCodeFixTitle");
/// <summary>Avoid calling 'ToLower', 'ToUpper', 'ToLowerInvariant' and 'ToUpperInvariant' to perform case-insensitive string comparisons, as in 'string.ToLower() == string.ToLower()', because they lead to an allocation. Instead, use 'string.Equals(string, StringCompar ...</summary>
internal static string @RecommendCaseInsensitiveStringEqualsDescription => GetResourceString("RecommendCaseInsensitiveStringEqualsDescription");
/// <summary>Prefer using 'string.Equals(string, StringComparison)' to perform a case-insensitive comparison, but keep in mind that this might cause subtle changes in behavior, so make sure to conduct thorough testing after applying the suggestion, or if culturally sen ...</summary>
internal static string @RecommendCaseInsensitiveStringEqualsMessage => GetResourceString("RecommendCaseInsensitiveStringEqualsMessage");
/// <summary>Use the 'StringComparison' method overloads to perform case-insensitive string comparisons</summary>
internal static string @RecommendCaseInsensitiveStringComparisonTitle => GetResourceString("RecommendCaseInsensitiveStringComparisonTitle");
/// <summary>Avoid calling 'ToLower', 'ToUpper', 'ToLowerInvariant' and 'ToUpperInvariant' to perform case-insensitive string comparisons because they lead to an allocation. Instead, prefer calling the method overloads of 'Contains', 'IndexOf' and 'StartsWith' that tak ...</summary>
internal static string @RecommendCaseInsensitiveStringComparisonDescription => GetResourceString("RecommendCaseInsensitiveStringComparisonDescription");
/// <summary>Prefer the string comparison method overload of '{0}' that takes a 'StringComparison' enum value to perform a case-insensitive comparison, but keep in mind that this might cause subtle changes in behavior, so make sure to conduct thorough testing after app ...</summary>
internal static string @RecommendCaseInsensitiveStringComparisonMessage => GetResourceString("RecommendCaseInsensitiveStringComparisonMessage");
/// <summary>Use 'TryAdd(TKey, TValue)'</summary>
internal static string @PreferDictionaryTryAddValueCodeFixTitle => GetResourceString("PreferDictionaryTryAddValueCodeFixTitle");
/// <summary>Prefer the 'IDictionary.TryAdd(TKey, TValue)' method</summary>
internal static string @PreferDictionaryTryAddTitle => GetResourceString("PreferDictionaryTryAddTitle");
/// <summary>To avoid double lookup, call 'TryAdd' instead of calling 'Add' with a 'ContainsKey' guard</summary>
internal static string @PreferDictionaryTryAddMessage => GetResourceString("PreferDictionaryTryAddMessage");
/// <summary>Prefer a 'TryAdd' call over an 'Add' call guarded by a 'ContainsKey' check. 'TryAdd' behaves the same as 'Add', except that when the specified key already exists, it returns 'false' instead of throwing an exception.</summary>
internal static string @PreferDictionaryTryAddDescription => GetResourceString("PreferDictionaryTryAddDescription");
/// <summary>Use 'CompositeFormat'</summary>
internal static string @UseCompositeFormatTitle => GetResourceString("UseCompositeFormatTitle");
/// <summary>Cache a 'CompositeFormat' for repeated use in this formatting operation</summary>
internal static string @UseCompositeFormatMessage => GetResourceString("UseCompositeFormatMessage");
/// <summary>Cache and use a 'CompositeFormat' instance as the argument to this formatting operation, rather than passing in the original format string. This reduces the cost of the formatting operation.</summary>
internal static string @UseCompositeFormatDescription => GetResourceString("UseCompositeFormatDescription");
/// <summary>The char overload is a better performing overload than a string with a single char.</summary>
internal static string @UseStringMethodCharOverloadWithSingleCharactersDescription => GetResourceString("UseStringMethodCharOverloadWithSingleCharactersDescription");
/// <summary>Use 'string.{0}(char)' instead of 'string.{0}(string)' when you have a string with a single char</summary>
internal static string @UseStringMethodCharOverloadWithSingleCharactersMessage => GetResourceString("UseStringMethodCharOverloadWithSingleCharactersMessage");
/// <summary>Use char overload</summary>
internal static string @UseStringMethodCharOverloadWithSingleCharactersTitle => GetResourceString("UseStringMethodCharOverloadWithSingleCharactersTitle");
/// <summary>In many situations, logging is disabled or set to a log level that results in an unnecessary evaluation for this argument.</summary>
internal static string @AvoidPotentiallyExpensiveCallWhenLoggingDescription => GetResourceString("AvoidPotentiallyExpensiveCallWhenLoggingDescription");
/// <summary>Evaluation of this argument may be expensive and unnecessary if logging is disabled ({0})</summary>
internal static string @AvoidPotentiallyExpensiveCallWhenLoggingMessage => GetResourceString("AvoidPotentiallyExpensiveCallWhenLoggingMessage");
/// <summary>Avoid potentially expensive logging</summary>
internal static string @AvoidPotentiallyExpensiveCallWhenLoggingTitle => GetResourceString("AvoidPotentiallyExpensiveCallWhenLoggingTitle");
/// <summary>anonymous object creation</summary>
internal static string @AvoidPotentiallyExpensiveCallWhenLoggingReasonAnonymousObjectCreation => GetResourceString("AvoidPotentiallyExpensiveCallWhenLoggingReasonAnonymousObjectCreation");
/// <summary>array creation</summary>
internal static string @AvoidPotentiallyExpensiveCallWhenLoggingReasonArrayCreation => GetResourceString("AvoidPotentiallyExpensiveCallWhenLoggingReasonArrayCreation");
/// <summary>await expression</summary>
internal static string @AvoidPotentiallyExpensiveCallWhenLoggingReasonAwaitExpression => GetResourceString("AvoidPotentiallyExpensiveCallWhenLoggingReasonAwaitExpression");
/// <summary>boxing conversion</summary>
internal static string @AvoidPotentiallyExpensiveCallWhenLoggingReasonBoxingConversion => GetResourceString("AvoidPotentiallyExpensiveCallWhenLoggingReasonBoxingConversion");
/// <summary>collection expression</summary>
internal static string @AvoidPotentiallyExpensiveCallWhenLoggingReasonCollectionExpression => GetResourceString("AvoidPotentiallyExpensiveCallWhenLoggingReasonCollectionExpression");
/// <summary>method invocation</summary>
internal static string @AvoidPotentiallyExpensiveCallWhenLoggingReasonMethodInvocation => GetResourceString("AvoidPotentiallyExpensiveCallWhenLoggingReasonMethodInvocation");
/// <summary>object creation</summary>
internal static string @AvoidPotentiallyExpensiveCallWhenLoggingReasonObjectCreation => GetResourceString("AvoidPotentiallyExpensiveCallWhenLoggingReasonObjectCreation");
/// <summary>string interpolation</summary>
internal static string @AvoidPotentiallyExpensiveCallWhenLoggingReasonStringInterpolation => GetResourceString("AvoidPotentiallyExpensiveCallWhenLoggingReasonStringInterpolation");
/// <summary>with expression</summary>
internal static string @AvoidPotentiallyExpensiveCallWhenLoggingReasonWithExpression => GetResourceString("AvoidPotentiallyExpensiveCallWhenLoggingReasonWithExpression");
/// <summary>Avoid creating a new 'JsonSerializerOptions' instance for every serialization operation. Cache and reuse instances instead.</summary>
internal static string @AvoidSingleUseOfLocalJsonSerializerOptionsMessage => GetResourceString("AvoidSingleUseOfLocalJsonSerializerOptionsMessage");
/// <summary>Avoid creating a new 'JsonSerializerOptions' instance for every serialization operation. Cache and reuse instances instead. Single use 'JsonSerializerOptions' instances can substantially degrade the performance of your application.</summary>
internal static string @AvoidSingleUseOfLocalJsonSerializerOptionsDescription => GetResourceString("AvoidSingleUseOfLocalJsonSerializerOptionsDescription");
/// <summary>Cache and reuse 'JsonSerializerOptions' instances</summary>
internal static string @AvoidSingleUseOfLocalJsonSerializerOptionsTitle => GetResourceString("AvoidSingleUseOfLocalJsonSerializerOptionsTitle");
/// <summary>Do not pass a non-nullable value to 'ArgumentNullException.ThrowIfNull'</summary>
internal static string @DoNotPassNonNullableValueToArgumentNullExceptionThrowIfNullTitle => GetResourceString("DoNotPassNonNullableValueToArgumentNullExceptionThrowIfNullTitle");
/// <summary>Calling 'ArgumentNullException.ThrowIfNull' and passing a non-nullable value is a no-op</summary>
internal static string @DoNotPassNonNullableValueToArgumentNullExceptionThrowIfNullMessage => GetResourceString("DoNotPassNonNullableValueToArgumentNullExceptionThrowIfNullMessage");
/// <summary>'ArgumentNullException.ThrowIfNull' throws when the passed argument is 'null'. Certain constructs like non-nullable structs, 'nameof()' and 'new' expressions are known to never be null, so 'ArgumentNullException.ThrowIfNull' will never throw.</summary>
internal static string @DoNotPassNonNullableValueToArgumentNullExceptionThrowIfNullDescription => GetResourceString("DoNotPassNonNullableValueToArgumentNullExceptionThrowIfNullDescription");
/// <summary>Remove superfluous 'ArgumentNullException.ThrowIfNull' call</summary>
internal static string @DoNotPassNonNullableValueToArgumentNullExceptionThrowIfNullCodeFixTitle => GetResourceString("DoNotPassNonNullableValueToArgumentNullExceptionThrowIfNullCodeFixTitle");
/// <summary>Do not pass a nullable struct to 'ArgumentNullException.ThrowIfNull'</summary>
internal static string @DoNotPassNullableStructToArgumentNullExceptionThrowIfNullTitle => GetResourceString("DoNotPassNullableStructToArgumentNullExceptionThrowIfNullTitle");
/// <summary>Passing a nullable struct to 'ArgumentNullException.ThrowIfNull' may cause boxing</summary>
internal static string @DoNotPassNullableStructToArgumentNullExceptionThrowIfNullMessage => GetResourceString("DoNotPassNullableStructToArgumentNullExceptionThrowIfNullMessage");
/// <summary>'ArgumentNullException.ThrowIfNull' accepts an 'object', so passing a nullable struct may cause the value to be boxed.</summary>
internal static string @DoNotPassNullableStructToArgumentNullExceptionThrowIfNullDescription => GetResourceString("DoNotPassNullableStructToArgumentNullExceptionThrowIfNullDescription");
/// <summary>Replace the 'ArgumentNullException.ThrowIfNull' call with a conditional</summary>
internal static string @DoNotPassNullableStructToArgumentNullExceptionThrowIfNullCodeFixTitle => GetResourceString("DoNotPassNullableStructToArgumentNullExceptionThrowIfNullCodeFixTitle");
/// <summary>Comparing a span to 'null' or 'default' might not do what you intended. 'default' and the 'null' literal are implicitly converted to 'Span<T>.Empty'. Remove the redundant comparison or make the code more explicit by using 'IsEmpty'.</summary>
internal static string @DoNotCompareSpanToNullOrDefaultDescription => GetResourceString("DoNotCompareSpanToNullOrDefaultDescription");
/// <summary>Comparing a span to 'null' might be redundant, the 'null' literal will be implicitly converted to a 'Span<T>.Empty'</summary>
internal static string @DoNotCompareSpanToNullMessage => GetResourceString("DoNotCompareSpanToNullMessage");
/// <summary>Comparing a span to 'default' might not do what you intended, make the code more explicit by checking 'IsEmpty'</summary>
internal static string @DoNotCompareSpanToDefaultMessage => GetResourceString("DoNotCompareSpanToDefaultMessage");
/// <summary>Do not compare Span<T> to 'null' or 'default'</summary>
internal static string @DoNotCompareSpanToNullOrDefaultTitle => GetResourceString("DoNotCompareSpanToNullOrDefaultTitle");
/// <summary>Use 'IsEmpty'</summary>
internal static string @DoNotCompareSpanToNullIsEmptyCodeFixTitle => GetResourceString("DoNotCompareSpanToNullIsEmptyCodeFixTitle");
/// <summary>Replace obsolete call</summary>
internal static string @DoNotUseThreadVolatileReadWriteCodeFixTitle => GetResourceString("DoNotUseThreadVolatileReadWriteCodeFixTitle");
/// <summary>File-based program entry point should start with '#!'</summary>
internal static string @MissingShebangInFileBasedProgramTitle => GetResourceString("MissingShebangInFileBasedProgramTitle");
/// <summary>When a file-based program consists of multiple files, the entry point file should start with a shebang ('#!') line to clearly distinguish it from other included files.</summary>
internal static string @MissingShebangInFileBasedProgramDescription => GetResourceString("MissingShebangInFileBasedProgramDescription");
/// <summary>File-based program entry point should start with '#!'</summary>
internal static string @MissingShebangInFileBasedProgramMessage => GetResourceString("MissingShebangInFileBasedProgramMessage");
/// <summary>Add '#!' (shebang)</summary>
internal static string @MissingShebangInFileBasedProgramCodeFixTitle => GetResourceString("MissingShebangInFileBasedProgramCodeFixTitle");
/// <summary>Collapse consecutive Path.Combine or Path.Join operations</summary>
internal static string @CollapseMultiplePathOperationsTitle => GetResourceString("CollapseMultiplePathOperationsTitle");
/// <summary>Multiple consecutive Path.{0} operations can be collapsed into a single operation</summary>
internal static string @CollapseMultiplePathOperationsMessage => GetResourceString("CollapseMultiplePathOperationsMessage");
/// <summary>When multiple Path.Combine or Path.Join operations are nested, they can be collapsed into a single operation for better performance and readability.</summary>
internal static string @CollapseMultiplePathOperationsDescription => GetResourceString("CollapseMultiplePathOperationsDescription");
/// <summary>Collapse into single Path.{0} operation</summary>
internal static string @CollapseMultiplePathOperationsCodeFixTitle => GetResourceString("CollapseMultiplePathOperationsCodeFixTitle");
/// <summary>Use 'ReadOnlySpan<T>' or 'ReadOnlyMemory<T>' instead of 'Span<T>' or 'Memory<T>'</summary>
internal static string @PreferReadOnlySpanOverSpanTitle => GetResourceString("PreferReadOnlySpanOverSpanTitle");
/// <summary>Parameter '{0}' can be declared as '{1}' instead of as '{2}'</summary>
internal static string @PreferReadOnlySpanOverSpanMessage => GetResourceString("PreferReadOnlySpanOverSpanMessage");
/// <summary>Using 'ReadOnlySpan<T>' or 'ReadOnlyMemory<T>' instead of 'Span<T>' or 'Memory<T>' for parameters that are not written to can prevent errors, convey intent more clearly, and may improve performance.</summary>
internal static string @PreferReadOnlySpanOverSpanDescription => GetResourceString("PreferReadOnlySpanOverSpanDescription");
/// <summary>Change to '{0}'</summary>
internal static string @PreferReadOnlySpanOverSpanCodeFixTitle => GetResourceString("PreferReadOnlySpanOverSpanCodeFixTitle");
}
}