File: Resources.Designer.cs
Web Access
Project: src\src\Analyzers\Microsoft.Analyzers.Extra\Microsoft.Analyzers.Extra.csproj (Microsoft.Analyzers.Extra)
//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------
 
namespace Microsoft.Extensions.ExtraAnalyzers {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option, or rebuild your VS project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "17.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class Resources {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal Resources() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Microsoft.Extensions.ExtraAnalyzers.Resources", typeof(Resources).Assembly);
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Dictionaries and sets which use enums and bytes as keys can often be replaced with simple arrays for improved performance.
        /// </summary>
        internal static string ArraysDescription {
            get {
                return ResourceManager.GetString("ArraysDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Consider using &apos;{0}?[]&apos; instead of &apos;{1}&apos;.
        /// </summary>
        internal static string ArraysMessage {
            get {
                return ResourceManager.GetString("ArraysMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Consider using an array instead of a collection.
        /// </summary>
        internal static string ArraysTitle {
            get {
                return ResourceManager.GetString("ArraysTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When skipping the await keyword for asynchronous operations inside a using block, then a disposable object could be disposed before the asynchronous invocation finishes. This might result in incorrect behavior and very often ends with a runtime exception notifying that the code is trying to operate on a disposed object..
        /// </summary>
        internal static string AsyncCallInsideUsingBlockDescription {
            get {
                return ResourceManager.GetString("AsyncCallInsideUsingBlockDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Async call should be awaited before leaving the &apos;using&apos; block.
        /// </summary>
        internal static string AsyncCallInsideUsingBlockMessage {
            get {
                return ResourceManager.GetString("AsyncCallInsideUsingBlockMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Fire-and-forget async call inside a &apos;using&apos; block.
        /// </summary>
        internal static string AsyncCallInsideUsingBlockTitle {
            get {
                return ResourceManager.GetString("AsyncCallInsideUsingBlockTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Accepting a CancellationToken as a parameter allows caller to express a loss of interest in the result enabling the method to save cycles by finishing early.
        /// </summary>
        internal static string AsyncMethodWithoutCancellationDescription {
            get {
                return ResourceManager.GetString("AsyncMethodWithoutCancellationDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Add CancellationToken as the parameter of asynchronous method.
        /// </summary>
        internal static string AsyncMethodWithoutCancellationMessage {
            get {
                return ResourceManager.GetString("AsyncMethodWithoutCancellationMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The async method doesn&apos;t support cancellation.
        /// </summary>
        internal static string AsyncMethodWithoutCancellationTitle {
            get {
                return ResourceManager.GetString("AsyncMethodWithoutCancellationTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Using the null coalescing assignment operator (??=) with values which are statically known not to be null causes superfluous null checks to be performed at runtime.
        /// </summary>
        internal static string CoalesceAssignmentDescription {
            get {
                return ResourceManager.GetString("CoalesceAssignmentDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Consider removing unnecessary null coalescing assignment (??=) since the target value is statically known not to be null.
        /// </summary>
        internal static string CoalesceAssignmentMessage {
            get {
                return ResourceManager.GetString("CoalesceAssignmentMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Consider removing unnecessary null coalescing assignment (??=).
        /// </summary>
        internal static string CoalesceAssignmentTitle {
            get {
                return ResourceManager.GetString("CoalesceAssignmentTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Using the null coalescing operator (??) with values which are statically known to be null causes superfluous null checks to be performed at runtime.
        /// </summary>
        internal static string CoalesceDescription {
            get {
                return ResourceManager.GetString("CoalesceDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Consider removing unnecessary null coalescing (??) since the left-hand value is statically known not to be null.
        /// </summary>
        internal static string CoalesceMessage {
            get {
                return ResourceManager.GetString("CoalesceMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Consider removing unnecessary null coalescing operator (??).
        /// </summary>
        internal static string CoalesceTitle {
            get {
                return ResourceManager.GetString("CoalesceTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Using the conditional access operator (?) to access values which are statically known not to be null causes superfluous null checks to be performed at runtime.
        /// </summary>
        internal static string ConditionalAccessDescription {
            get {
                return ResourceManager.GetString("ConditionalAccessDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Consider removing unnecessary conditional access operator (?) since the value is statically known not to be null.
        /// </summary>
        internal static string ConditionalAccessMessage {
            get {
                return ResourceManager.GetString("ConditionalAccessMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Consider removing unnecessary conditional access operator (?).
        /// </summary>
        internal static string ConditionalAccessTitle {
            get {
                return ResourceManager.GetString("ConditionalAccessTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Generate a strongly-typed logging method.
        /// </summary>
        internal static string GenerateStronglyTypedLoggingMethod {
            get {
                return ResourceManager.GetString("GenerateStronglyTypedLoggingMethod", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Using generic collections can avoid boxing overhead and provides strong typing.
        /// </summary>
        internal static string LegacyCollectionDescription {
            get {
                return ResourceManager.GetString("LegacyCollectionDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use generic collections instead of legacy collections for improved performance.
        /// </summary>
        internal static string LegacyCollectionMessage {
            get {
                return ResourceManager.GetString("LegacyCollectionMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use generic collections instead of legacy collections for improved performance.
        /// </summary>
        internal static string LegacyCollectionTitle {
            get {
                return ResourceManager.GetString("LegacyCollectionTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Identifies calls to legacy logging methods.
        /// </summary>
        internal static string LegacyLoggingDescription {
            get {
                return ResourceManager.GetString("LegacyLoggingDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use source generated logging methods for improved performance.
        /// </summary>
        internal static string LegacyLoggingMessage {
            get {
                return ResourceManager.GetString("LegacyLoggingMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use source generated logging methods for improved performance.
        /// </summary>
        internal static string LegacyLoggingTitle {
            get {
                return ResourceManager.GetString("LegacyLoggingTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Making an executable&apos;s types internal enables dead code analysis along with other potential optimizations.
        /// </summary>
        internal static string MakeExeTypesInternalDescription {
            get {
                return ResourceManager.GetString("MakeExeTypesInternalDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Make type &apos;{0}&apos; internal since it is declared in an executable.
        /// </summary>
        internal static string MakeExeTypesInternalMessage {
            get {
                return ResourceManager.GetString("MakeExeTypesInternalMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Make types declared in an executable internal.
        /// </summary>
        internal static string MakeExeTypesInternalTitle {
            get {
                return ResourceManager.GetString("MakeExeTypesInternalTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Make the type internal.
        /// </summary>
        internal static string MakeTypeInternal {
            get {
                return ResourceManager.GetString("MakeTypeInternal", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Apply code fix for all issues in &apos;{0}&apos; &apos;{1}&apos;.
        /// </summary>
        internal static string SequentialFixAllFormat {
            get {
                return ResourceManager.GetString("SequentialFixAllFormat", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Apply code fix for all issues in current solution.
        /// </summary>
        internal static string SequentialFixAllInSolution {
            get {
                return ResourceManager.GetString("SequentialFixAllInSolution", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;System.MemoryExtensions.Split&apos; for improved performance.
        /// </summary>
        internal static string SplitDescription {
            get {
                return ResourceManager.GetString("SplitDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;System.MemoryExtensions.Split&apos; for improved performance.
        /// </summary>
        internal static string SplitMessage {
            get {
                return ResourceManager.GetString("SplitMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;System.MemoryExtensions.Split&apos; for improved performance.
        /// </summary>
        internal static string SplitTitle {
            get {
                return ResourceManager.GetString("SplitTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When checking for a single character, prefer the character overloads of &apos;String.StartsWith&apos; and &apos;String.EndsWith&apos; for improved performance.
        /// </summary>
        internal static string StartsEndsWithDescription {
            get {
                return ResourceManager.GetString("StartsEndsWithDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the character-based overload of &apos;{0}&apos;.
        /// </summary>
        internal static string StartsEndsWithMessage {
            get {
                return ResourceManager.GetString("StartsEndsWithMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the character-based overloads of &apos;String.StartsWith&apos; or &apos;String.EndsWith&apos;.
        /// </summary>
        internal static string StartsEndsWithTitle {
            get {
                return ResourceManager.GetString("StartsEndsWithTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Identifies uses of time dependent APIs that can lead to flaky tests.
        /// </summary>
        internal static string StaticTimeDescription {
            get {
                return ResourceManager.GetString("StaticTimeDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;System.TimeProvider&apos; to make the code easier to test.
        /// </summary>
        internal static string StaticTimeMessage {
            get {
                return ResourceManager.GetString("StaticTimeMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;System.TimeProvider&apos; to make the code easier to test.
        /// </summary>
        internal static string StaticTimeTitle {
            get {
                return ResourceManager.GetString("StaticTimeTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Identifies calls to the &apos;ToString&apos; method as arguments to a logging method.
        /// </summary>
        internal static string UsingToStringInLoggersDescription {
            get {
                return ResourceManager.GetString("UsingToStringInLoggersDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Provide a logging method that accepts an instance of the object instead of a string.
        /// </summary>
        internal static string UsingToStringInLoggersMessage {
            get {
                return ResourceManager.GetString("UsingToStringInLoggersMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Perform message formatting in the body of the logging method.
        /// </summary>
        internal static string UsingToStringInLoggersTitle {
            get {
                return ResourceManager.GetString("UsingToStringInLoggersTitle", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Using &apos;System.ValueTuple&apos; avoids allocations and is generally more efficient than &apos;System.Tuple&apos;.
        /// </summary>
        internal static string ValueTupleDescription {
            get {
                return ResourceManager.GetString("ValueTupleDescription", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;System.ValueTuple&apos; instead of &apos;System.Tuple&apos; for improved performance.
        /// </summary>
        internal static string ValueTupleMessage {
            get {
                return ResourceManager.GetString("ValueTupleMessage", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use &apos;System.ValueTuple&apos; instead of &apos;System.Tuple&apos; for improved performance.
        /// </summary>
        internal static string ValueTupleTitle {
            get {
                return ResourceManager.GetString("ValueTupleTitle", resourceCulture);
            }
        }
    }
}