Prestandaregler

Prestandaregler stöder bibliotek och program med höga prestanda.

I detta avsnitt

Regel	beskrivning
CA1802: Använd literaler där det är lämpligt	Ett fält deklareras som statiskt och skrivskyddat (Shared och ReadOnly i Visual Basic) och initieras med ett värde som kan beräknas vid kompilering. Eftersom värdet som tilldelas till målfältet är beräkningsbart vid kompileringstillfället ändrar du deklarationen till ett const-fält (Const i Visual Basic) så att värdet beräknas vid kompileringstid i stället för vid körning.
CA1805: Initiera inte i onödan	.NET-körningen initierar alla fält av referenstyper till standardvärdena innan konstruktorn körs. I de flesta fall är det redundant att uttryckligen initiera ett fält till standardvärdet, vilket ökar underhållskostnaderna och kan försämra prestanda (till exempel med ökad sammansättningsstorlek).
CA1806: Ignorera inte metodresultat	Ett nytt objekt skapas men används aldrig, eller en metod som skapar och returnerar en ny sträng anropas och den nya strängen används aldrig, eller så returnerar en KOMPONENTobjektmodell (COM) eller P/Invoke-metod en HRESULT- eller felkod som aldrig används.
CA1810: Initiera statiska fält av referenstyp direkt	När en typ deklarerar en explicit statisk konstruktor lägger JIT-kompilatorn (just-in-time) till en kontroll till varje statisk metod och instanskonstruktor av typen för att kontrollera att den statiska konstruktorn tidigare anropades. Statiska konstruktorkontroller kan minska prestandan.
CA1812: Undvik oinstifierade interna klasser	En instans av en typ av sammansättningsnivå skapas inte av kod i sammansättningen.
CA1813: Undvik oförseglade attribut	.NET tillhandahåller metoder för att hämta anpassade attribut. Som standard söker dessa metoder i arvshierarkin för attribut. Att försegla attributet eliminerar sökningen genom arvshierarkin och kan förbättra prestandan.
CA1814: Föredrar ojämna matriser framför flerdimensionella	En ojämn matris är en matris vars element är matriser. Matriserna som utgör elementen kan ha olika storlekar, vilket kan leda till mindre utrymme för vissa datauppsättningar.
CA1815: Åsidosätt Equals och likhetsoperatorn på värdetyper	För värdetyper använder den ärvda implementeringen av Equals biblioteket Reflektion och jämför innehållet i alla fält. Reflektion är beräkningsmässigt dyrt, och det kan vara onödigt att jämföra varje fält för likhet. Om du förväntar dig att användare ska jämföra eller sortera instanser, eller att använda instanser som nycklar i hashtabeller, bör din värdetyp implementera Equals.
CA1819: Egenskaper bör inte returnera matriser	Matriser som returneras av egenskaper är inte skrivskyddade, även om egenskapen är skrivskyddad. För att hålla matrisen manipulationssäker måste egenskapen returnera en kopia av matrisen. Vanligtvis förstår användarna inte de negativa prestandakonsekvenserna av att anropa en sådan egenskap.
CA1820: Testa om strängar är tomma genom att använda strängens längd	Det går betydligt snabbare att jämföra strängar med egenskapen String.Length eller metoden String.IsNullOrEmpty än att använda Equals.
CA1821: Ta bort tomma finalizerare	Undvik finaliserare när det är möjligt på grund av den extra prestandaoverhead som uppstår vid spårning av objektets livslängd. En tom finalizer medför extra kostnader utan någon fördel.
CA1822: Markera medlemmar som statiska	Medlemmar som inte har åtkomst till instansdata eller anropar instansmetoder kan markeras som statiska (delade i Visual Basic). När du har markerat metoderna som statiska genererar kompilatorn icke-virtuella anropswebbplatser till dessa medlemmar. Detta kan ge dig en mätbar prestandavinst för prestandakänslig kod.
CA1823: Undvik oanvända privata fält	Privata fält har identifierats som inte verkar vara tillgängliga i sammansättningen.
CA1824: Markera sammansättningar med NeutralResourcesLanguageAttribute	Attributet NeutralResourcesLanguage informerar Resource Manager om språket som användes för att visa resurserna i en neutral kultur för en sammansättning. Detta förbättrar uppslagsprestandan för den första resursen som du läser in och kan minska din arbetsuppsättning.
CA1825: Undvik matrisallokeringar med noll längd	Initiering av en matris med noll längd leder till onödig minnesallokering. Använd i stället den statiskt allokerade tomma matrisinstansen genom att anropa Array.Empty. Minnesallokeringen delas över alla anrop för den här metoden.
CA1826: Använd egenskapen i stället för Linq Enumerable-metoden	Enumerable LINQ-metoden användes på en typ som stöder en motsvarande, effektivare egenskap.
CA1827: Använd inte Count/LongCount när Any kan användas	Count eller LongCount -metoden användes där Any metoden skulle vara effektivare.
CA1828: Använd inte CountAsync/LongCountAsync när AnyAsync kan användas	CountAsync eller LongCountAsync -metoden användes där AnyAsync metoden skulle vara effektivare.
CA1829: Använd egenskapen Length/Count i stället för metoden Enumerable.Count	Count En LINQ-metod användes på en typ som stöder en motsvarande, effektivare Length- eller Count-egenskap.
CA1830: Använd starkt typbestämda överlagringar av metoderna Append och Insert på StringBuilder	Append och Insert ger överlagringar för flera typer utöver System.String. Om möjligt bör du föredra de starkt typade överlagringarna i stället för att använda ToString() och den strängbaserade överlagringen.
CA1831: Använd AsSpan i stället för Intervallbaserade indexerare för sträng när det är lämpligt	När du använder en intervallindexerare på en sträng och implicit tilldelar värdet till typen ReadOnlySpan<char> används metoden Substring i stället för Slice, vilket skapar en kopia av den begärda delen av strängen.
CA1832: Använd AsSpan eller AsMemory i stället för Intervallbaserade indexerare för att hämta ReadOnlySpan- eller ReadOnlyMemory-delen av en matris	När du använder en range-indexer på en matris och implicit tilldelar värdet till en ReadOnlySpan<T> eller ReadOnlyMemory<T> -typ, används metoden GetSubArray i stället för Slice, som genererar en kopia av den begärda delen av matrisen.
CA1833: Använd AsSpan eller AsMemory i stället för Intervallbaserade indexerare för att hämta span- eller minnesdelen av en matris	När du använder en range-indexer på en matris och implicit tilldelar värdet till en Span<T> eller Memory<T> -typ, används metoden GetSubArray i stället för Slice, som genererar en kopia av den begärda delen av matrisen.
CA1834: Använd StringBuilder.Append(char) för strängar med ett tecken	StringBuilder har en Append-överlagrad version som tar char som argument. Hellre anropa överbelastningen char för att förbättra prestandan.
CA1835: Föredrar "Minnesbaserade överlagringar" för "ReadAsync" och "WriteAsync"	"Stream" har en "ReadAsync"-överlagring som tar ett "minnesbyte<>" som det första argumentet och en "WriteAsync"-överlagring som tar en "ReadOnlyMemory<Byte>" som det första argumentet. Välj att anropa minnesbaserade överlagringar, som är mer effektiva.
CA1836: Föredra IsEmpty framför Count när det är tillgängligt	Föredrar IsEmpty egenskapen som är effektivare än Count, Lengtheller Count<TSource>(IEnumerable<TSource>)LongCount<TSource>(IEnumerable<TSource>) för att avgöra om objektet innehåller eller inte några objekt.
CA1837: Använd Environment.ProcessId i stället för Process.GetCurrentProcess().Id	Environment.ProcessId är enklare och snabbare än Process.GetCurrentProcess().Id.
CA1838: Undvik StringBuilder parametrar för P/Invokes	Marshalling av StringBuilder skapar alltid en intern buffertkopia, vilket resulterar i flera allokeringar för en marshallingåtgärd.
CA1839: Använd Environment.ProcessPath i stället för Process.GetCurrentProcess(). MainModule.FileName	Environment.ProcessPath är enklare och snabbare än Process.GetCurrentProcess().MainModule.FileName.
CA1840: Använd Environment.CurrentManagedThreadId i stället för Thread.CurrentThread.ManagedThreadId	Environment.CurrentManagedThreadId är mer kompakt och effektiv än Thread.CurrentThread.ManagedThreadId.
CA1841: Använd Dictionary.Contains-metoder	Att anropa Contains på samlingen Keys eller Values kan ofta vara dyrare än att anropa ContainsKey eller ContainsValue på själva ordboken.
CA1842: Använd inte "WhenAll" med en enda uppgift	Användning WhenAll med en enskild uppgift kan leda till prestandaförlust. Vänta eller återlämna uppgiften i stället.
CA1843: Använd inte "WaitAll" med en enda uppgift	Användning WaitAll med en enskild uppgift kan leda till prestandaförlust. Vänta på eller lämna tillbaka uppgiften i stället.
CA1844: Ange minnesbaserade åsidosättningar av asynkrona metoder vid underklassning av "Stream"	För att förbättra prestandan åsidosätter du de minnesbaserade asynkrona metoderna när du underklassar "Stream". Implementera sedan de matrisbaserade metoderna när det gäller minnesbaserade metoder.
CA1845: Använd span-baserad 'string.Concat'	Det är mer effektivt att använda AsSpan och string.Concat, i stället för Substring och en sammanlänkningsoperator.
CA1846: Föredra AsSpan framför Substring	AsSpan är effektivare än Substring. Substring utför en O(n) strängkopia, men AsSpan har inte och har en konstant kostnad. AsSpan utför inte heller några heap-allokeringar.
CA1847: Använd teckenliteral för en sökning med ett enda tecken	Använd String.Contains(char) i stället String.Contains(string) för när du söker efter ett enda tecken.
CA1848: Använd LoggerMessage-delegaterna	För bättre prestanda, använd LoggerMessage delegater.
CA1849: Anropa asynkrona metoder i en asynkron metod	I en metod som redan är asynkron bör anrop till andra metoder vara till deras asynkrona versioner, där de finns.
CA1850: Föredrar statisk HashData metod framför ComputeHash	Det är mer effektivt att använda den statiska HashData-metoden än att skapa och hantera en HashAlgorithm-instans för att anropa ComputeHash.
CA1851: Möjliga flera uppräkningar av IEnumerable samlingen	Möjliga flera uppräkningar av IEnumerable samlingen. Överväg att använda en implementering som undviker flera uppräkningar.
CA1852: Förslut interna typer	En typ som inte är tillgänglig utanför sammansättningen och som inte har några undertyper inom dess innehållande sammansättning är inte förseglad.
CA1853: Onödigt anrop till "Dictionary.ContainsKey(key)"	Det finns ingen anledning att skydda Dictionary.Remove(key) med Dictionary.ContainsKey(key). Dictionary<TKey,TValue>.Remove(TKey) kontrollerar redan om nyckeln finns och inte utlöser den om den inte finns.
CA1854: Föredrar metoden "IDictionary.TryGetValue(TKey, out TValue)"	Föredra "TryGetValue" framför en ordlisteindexerare som är skyddad av en "ContainsKey"-kontroll. "ContainsKey" och indexeraren letar båda upp nyckeln, så att använda "TryGetValue" undviker den extra sökningen.
CA1855: Använd Span<T>. Clear() i stället för Span<T>. Fill()	Det är mer effektivt att anropa Span<T>.Clear() än att anropa Span<T>.Fill(T) för att fylla elementen i intervallet med ett standardvärde.
CA1856: Felaktig användning av attributet ConstantExpected	Attributet ConstantExpectedAttribute tillämpas inte korrekt på en parameter.
CA1857: Parametern förväntar sig en konstant för optimala prestanda	Ett ogiltigt argument skickas till en parameter som kommenteras med ConstantExpectedAttribute.
CA1858: Använd StartsWith i stället för IndexOf	Det är mer effektivt att anropa String.StartsWith än att anropa String.IndexOf för att kontrollera om en sträng börjar med ett angivet prefix.
CA1859: Använd konkreta typer när det är möjligt för bättre prestanda	Koden använder gränssnittstyper eller abstrakta typer, vilket leder till onödiga gränssnittsanrop eller virtuella anrop.
CA1860: Undvik att använda tilläggsmetoden "Enumerable.Any()"	Det är mer effektivt och tydligare att använda Length, Counteller IsEmpty (om möjligt) än att anropa Enumerable.Any för att avgöra om en samlingstyp har några element.
CA1861: Undvik konstanta matriser som argument	Konstanta matriser som skickas som argument återanvänds inte, vilket innebär prestandakostnader. Överväg att extrahera dem till `static readonly`-fält för att förbättra prestanda.
CA1862: Använd metodöverlagringarna för 'StringComparison' för att utföra skiftlägesokänsliga strängjämförelser	När kod anropar ToLower() eller ToUpper() för att utföra en skiftlägesokänslig strängjämförelse utförs en onödig allokering.
CA1863: Använd "CompositeFormat"	För att minska kostnaden för formatering, cachelagra och använd en CompositeFormat-instans som argument till String.Format eller StringBuilder.AppendFormat.
CA1864: Föredrar metoden "IDictionary.TryAdd(TKey, TValue)"	Både Dictionary<TKey,TValue>.ContainsKey(TKey) och Dictionary<TKey,TValue>.Add utför en sökning, som är redundant. Det är mer effektivt att anropa Dictionary<TKey,TValue>.TryAdd, vilket returnerar ett bool som anger om värdet har lagts till eller inte. TryAdd skriver inte över nyckelns värde om nyckeln redan finns.
CA1865-CA1867: Använd teckenöverlagring	Char-överlagringen ger bättre prestanda för en sträng som innehåller ett enda tecken.
CA1868: Onödigt anrop till "Contains" för uppsättningar	Både ISet<T>.Add(T) och ICollection<T>.Remove(T) utför ett uppslag, vilket gör det redundant att anropa ICollection<T>.Contains(T) i förväg. Det är mer effektivt att anropa Add(T) eller Remove(T) direkt, vilket returnerar ett booleskt värde som anger om objektet har lagts till eller tagits bort.
CA1869: Cachelagrar och återanvänder "JsonSerializerOptions"-instanser	Om du använder en lokal instans av JsonSerializerOptions för serialisering eller deserialisering kan det avsevärt försämra programmets prestanda om koden körs flera gånger, eftersom System.Text.Json internt cachelagrar serialiseringsrelaterade metadata i den angivna instansen.
CA1870: Använd en cachelagrad "SearchValues"-instans	Att använda en cachelagrad SearchValues<T> instans är effektivare än att skicka värden direkt till IndexOfAny eller ContainsAny.
CA1871: Skicka inte en nullbar struct till "ArgumentNullException.ThrowIfNull"	"ArgumentNullException.ThrowIfNull" tar emot ett "object", så om du skickar in en nullbar struktur kan det leda till att värdet boxas.
CA1872: Föredrar "Convert.ToHexString" och "Convert.ToHexStringLower" framför anropskedjor baserade på "BitConverter.ToString"	Använd Convert.ToHexString eller Convert.ToHexStringLower när du kodar byte till en hexadecimal strängrepresentation. Dessa metoder är mer effektiva och allokeringsvänliga än att använda BitConverter.ToString i kombination med String.Replace för att ersätta bindestreck och String.ToLower.
CA1873: Undvik potentiellt dyr loggning	När loggningsmetoder anropas utvärderas deras argument oavsett om loggningsnivån är aktiverad. Detta kan leda till att dyra åtgärder körs även när loggmeddelandet inte skrivs. För bättre prestanda bör du skydda dyra loggningsanrop med en kontroll till IsEnabled eller använda LoggerMessage mönstret.
CA1874: Använd "Regex.IsMatch"	Regex.IsMatch är enklare och snabbare än Regex.Match(...).Success.
CA1875: Använd "Regex.Count"	Regex.Count är enklare och snabbare än Regex.Matches(...).Count.
CA1877: Använd överlagringar av Path.Combine eller Path.Join	Flera på varandra följande Path.Combine- eller Path.Join-åtgärder kan komprimeras till ett enda anrop med överlagringar som accepterar flera sökvägssegment.
CA1878: Föredrar ReadOnlySpan-egenskaper framför skrivskyddade matrisfält	Ett privat statiskt skrivskyddat konstantmatrisfält kan ersättas med en ReadOnlySpan<T> egenskap så att C#-kompilatorn kan undvika en hanterad matrisallokering.