Runtimekonfigurationsoptionen für Garbage Collection

Artikel
08/09/2024

Diese Seite enthält Informationen zu Einstellungen für den Garbage Collector (GC) der .NET-Runtime. Verwenden Sie diese Einstellungen, wenn Sie versuchen, die maximale Leistung einer ausgeführten App zu erzielen. Die Standardwerte bieten jedoch in typischen Situationen eine optimale Leistung für die meisten Anwendungen.

Einstellungen werden auf dieser Seite in Gruppen angeordnet. Die Einstellungen in den einzelnen Gruppen werden häufig zusammen verwendet, um ein bestimmtes Ergebnis zu erzielen.

Hinweis

Diese Konfigurationen werden von der Runtime nur gelesen, wenn der GC initialisiert wird (in der Regel während der Prozessstartzeit). Wenn Sie eine Umgebungsvariable ändern, während ein Prozess bereits ausgeführt wird, wird die Änderung in diesem Prozess nicht berücksichtigt. Einstellungen, die zur Laufzeit über APIs geändert werden können (etwa die Latenzebene), sind auf dieser Seite nicht aufgeführt.
Da die Garbage Collection pro Prozess ausgeführt wird, ist es selten sinnvoll, diese Konfigurationen auf Computerebene festzulegen. Beispielsweise möchten Sie gewiss nicht, dass jeder .NET-Prozess auf einem Computer die Garbage Collection für Server oder dieselbe feste Heapgrenze verwendet.
Verwenden Sie für Zahlenwerte die dezimale Schreibweise für Einstellungen in der Datei runtimeconfig.json oder runtimeconfig.template.json und die hexadezimale Schreibweise für Einstellungen von Umgebungsvariablen. Bei hexadezimalen Werten können Sie sie mit dem oder ohne das Präfix „0x“ angeben.
Wenn Sie die Umgebungsvariablen verwenden, standardisieren .NET 6 und höhere Versionen das Präfix DOTNET_ anstelle von COMPlus_. Das Präfix COMPlus_ funktioniert jedoch weiterhin. Wenn Sie eine frühere Version der .NET-Runtime verwenden, sollten Sie weiterhin das Präfix COMPlus_ verwenden, z. B. COMPlus_gcServer.

Möglichkeiten zum Angeben der Konfiguration

Für unterschiedliche Versionen der .NET-Runtime gibt es verschiedene Möglichkeiten, die Konfigurationswerte anzugeben. Die folgende Tabelle enthält eine Zusammenfassung:

Konfigurationsspeicherort	.NET-Versionen, für die dieser Speicherort gilt	Formate	Interpretation
runtimeconfig.json file/ runtimeconfig.template.json file	.NET (Core)	n	n wird als Dezimalwert interpretiert.
Umgebungsvariable	.NET Framework, .NET (Core)	0xn oder n	n wird in beiden Formaten als Hexadezimalwert interpretiert.
app.config-Datei	.NET Framework	0xn	n wird als Hexadezimalwert¹ interpretiert.

¹ Sie können einen Wert ohne das Präfix 0x für eine Datei vom Typ „app.config“ angeben, dies wird jedoch nicht empfohlen. Bei .NET Framework 4.8 und höher wird aufgrund eines Fehlers ein Wert ohne das Präfix 0x als Hexadezimalwert interpretiert. In früheren Versionen von .NET Framework hingegen wird er als Dezimalwert interpretiert. Um zu vermeiden, dass Sie Ihre Konfiguration ändern müssen, verwenden Sie das Präfix 0x, wenn Sie einen Wert in der Datei „app.config“ angeben.

Wenn Sie beispielsweise 12 Heaps für GCHeapCount für eine .NET Framework-App namens A.exe angeben möchten, fügen Sie der Datei A.exe.config den folgenden XML-Code hinzu:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    ...
    <runtime>
        <gcServer enabled="true"/>
        <GCHeapCount>0xc</GCHeapCount>
    </runtime>
</configuration>

Sowohl für .NET (Core) als auch für .NET Framework können Sie Umgebungsvariablen verwenden.

Unter Windows mit .NET 6 oder einer höheren Version:

SET DOTNET_gcServer=1
SET DOTNET_GCHeapCount=c

Unter Windows mit .NET 5 oder einer früheren Version:

SET COMPlus_gcServer=1
SET COMPlus_GCHeapCount=c

In anderen Betriebssystemen:

Für .NET 6 oder höhere Versionen:

export DOTNET_gcServer=1
export DOTNET_GCHeapCount=c

Für .NET 5 oder frühere Versionen:

export COMPlus_gcServer=1
export COMPlus_GCHeapCount=c

Wenn Sie kein .NET Framework verwenden, können Sie den Wert auch in der Datei runtimeconfig.json oder runtimeconfig.template.json festlegen.

runtimeconfig.json-Datei:

{
  "runtimeOptions": {
   "configProperties": {
      "System.GC.Server": true,
      "System.GC.HeapCount": 12
   }
  }
}

runtimeconfig.template.json-Datei:

{
  "configProperties": {
    "System.GC.Server": true,
    "System.GC.HeapCount": 12
  }
}

Varianten der Garbage Collection

Die zwei Hauptvarianten der Garbage Collection sind Arbeitsstation-GC und Server-GC. Weitere Informationen zu den Unterschieden zwischen diesen beiden Varianten finden Sie unter Garbage Collection für die Arbeitsstation und Garbage Collection auf dem Server.

Die Untervarianten der Garbage Collection sind Hintergrund-GC und nicht gleichzeitige GC.

Verwenden Sie die folgenden Einstellungen, um Varianten der Garbage Collection auszuwählen:

Garbage Collection für Arbeitsstationen und Server im Vergleich
Garbage Collection im Hintergrund

Arbeitsstationen und Server im Vergleich

Konfiguriert, ob die Anwendung die Arbeitsstation-GC oder die Server-GC verwendet
Standard: Arbeitsstation-Garbage Collection. Dies entspricht der Einstellung des Werts auf false.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.Server`	`false` – Arbeitsstation `true` – Server	.NET Core 1.0
MSBuild-Eigenschaft	`ServerGarbageCollection`	`false` – Arbeitsstation `true` – Server	.NET Core 1.0
Umgebungsvariable	`COMPlus_gcServer`	`0` – Arbeitsstation `1` – Server	.NET Core 1.0
Umgebungsvariable	`DOTNET_gcServer`	`0` – Arbeitsstation `1` – Server	.NET 6
app.config für .NET Framework	GCServer	`false` – Arbeitsstation `true` – Server

Beispiele

runtimeconfig.json-Datei:

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.Server": true
      }
   }
}

runtimeconfig.template.json-Datei:

{
   "configProperties": {
      "System.GC.Server": true
   }
}

Projektdatei:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <ServerGarbageCollection>true</ServerGarbageCollection>
  </PropertyGroup>

</Project>

Garbage Collection im Hintergrund

Konfiguriert, ob die (gleichzeitige) Hintergrund-GC aktiviert ist
Standard: Garbage Collection im Hintergrund verwenden. Dies entspricht der Einstellung des Werts auf true.
Weitere Informationen finden Sie unter Hintergrund der Garbage Collection.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.Concurrent`	`true` – Hintergrund-GC `false` – nicht gleichzeitige GC	.NET Core 1.0
MSBuild-Eigenschaft	`ConcurrentGarbageCollection`	`true` – Hintergrund-GC `false` – nicht gleichzeitige GC	.NET Core 1.0
Umgebungsvariable	`COMPlus_gcConcurrent`	`1` – Hintergrund-GC `0` – nicht gleichzeitige GC	.NET Core 1.0
Umgebungsvariable	`DOTNET_gcConcurrent`	`1` – Hintergrund-GC `0` – nicht gleichzeitige GC	.NET 6
app.config für .NET Framework	gcConcurrent	`true` – Hintergrund-GC `false` – nicht gleichzeitige GC

Beispiele

runtimeconfig.json-Datei:

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.Concurrent": false
      }
   }
}

runtimeconfig.template.json-Datei:

{
   "configProperties": {
      "System.GC.Concurrent": false
   }
}

Projektdatei:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <ConcurrentGarbageCollection>false</ConcurrentGarbageCollection>
  </PropertyGroup>

</Project>

Verwalten des Ressourceneinsatzes

Verwenden Sie die folgenden Einstellungen, um die Speicher- und Prozessorauslastung des Garbage Collectors zu verwalten:

Zuordnen
Maske zuordnen
Bereiche zuordnen
CPU-Gruppen
Heapanzahl
Heap hard limit
Heap hard limit percent
Feste Grenzen pro Objekt heap
Feste Prozentsätze pro Objekt heap
Hohe Speicherauslastung (Prozent)
VM beibehalten

Weitere Informationen zu einigen dieser Einstellungen finden Sie im Blogeintrag Mittelweg zwischen Arbeitsstation- und Server-GC.

Heapanzahl

Schränkt die Anzahl von Heaps ein, die vom Garbage Collector erstellt werden
Gilt nur für die Garbage Collection des Servers.
Wenn die GC-Prozessoraffinität aktiviert ist (Standardeinstellung), ordnet die Einstellung für die Heapanzahl den ersten n Prozessoren n GC-Heaps/-Threads zu. (Verwenden Sie die Einstellungen AffinitizeMask oder AffinitizeRanges, um genau anzugeben, welche Prozessoren zugeordnet werden sollen.)
Wenn die GC-Prozessoraffinität deaktiviert ist, wird mit dieser Einstellung die Anzahl der GC-Heaps eingeschränkt.
Weitere Informationen finden Sie unter Hinweise zu GCHeapCount.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.HeapCount`	Dezimalwert	.NET Core 3.0
Umgebungsvariable	`COMPlus_GCHeapCount`	Hexadezimalwert	.NET Core 3.0
Umgebungsvariable	`DOTNET_GCHeapCount`	Hexadezimalwert	.NET 6
app.config für .NET Framework	GCHeapCount	Dezimalwert	.NET Framework 4.6.2

Diese Konfigurationseinstellung verfügt nicht über eine bestimmte MSBuild-Eigenschaft. Sie können jedoch stattdessen ein RuntimeHostConfigurationOption-MSBuild-Element hinzufügen. Verwenden Sie den Einstellungsnamen runtimeconfig.json als Wert des Include-Attributs. Ein Beispiel finden Sie unter MSBuild-Eigenschaften.

Beispiele

runtimeconfig.json-Datei:

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.HeapCount": 16
      }
   }
}

runtimeconfig.template.json-Datei:

{
   "configProperties": {
      "System.GC.HeapCount": 16
   }
}

Tipp

Wenn Sie die Option in runtimeconfig.json festlegen, geben Sie einen Dezimalwert an. Wenn Sie die Option als Umgebungsvariable festlegen, geben Sie einen Hexadezimalwert an. Für eine Einschränkung der Heapanzahl auf 16 wären die Werte beispielsweise 16 für die JSON-Datei und 0x10 oder 10 für die Umgebungsvariable.

Maske zuordnen

Gibt die genauen Prozessoren an, die Garbage-Collector-Threads verwenden sollen
Wenn die GC-Prozessoraffinität deaktiviert ist, wird diese Einstellung ignoriert.
Gilt nur für die Garbage Collection des Servers.
Der Wert ist eine Bitmaske, die die für den Prozess verfügbaren Prozessoren definiert. Beispielsweise ist ein Dezimalwert von 1023 (oder ein Hexadezimalwert von 0x3FF oder 3FF bei Verwendung der Umgebungsvariablen) in Binärschreibweise 0011 1111 1111. Dies gibt an, dass die ersten zehn Prozessoren verwendet werden sollen. Geben Sie einen Dezimalwert von 1047552 (oder einen Hexadezimalwert von 0xFFC00 oder FFC00) an, der einem Binärwert von 1111 1111 1100 0000 0000 entspricht, um die nächsten zehn Prozessoren anzugeben, d. h. die Prozessoren 10 bis 19.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.HeapAffinitizeMask`	Dezimalwert	.NET Core 3.0
Umgebungsvariable	`COMPlus_GCHeapAffinitizeMask`	Hexadezimalwert	.NET Core 3.0
Umgebungsvariable	`DOTNET_GCHeapAffinitizeMask`	Hexadezimalwert	.NET 6
app.config für .NET Framework	GCHeapAffinitizeMask	Dezimalwert	.NET Framework 4.6.2

Beispiele

runtimeconfig.json-Datei:

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.HeapAffinitizeMask": 1023
      }
   }
}

runtimeconfig.template.json-Datei:

{
   "configProperties": {
      "System.GC.HeapAffinitizeMask": 1023
   }
}

Bereiche zuordnen

Gibt die Liste der Prozessoren an, die für Garbage-Collector-Threads verwendet werden sollen
Diese Einstellung ähnelt System.GC.HeapAffinitizeMask, abgesehen davon, dass Sie mehr als 64 Prozessoren angeben können.
Stellen Sie für Windows-Betriebssysteme der Prozessornummer oder dem Prozessorbereich die entsprechende CPU-Gruppe voran, z. B. „0:1-10,0:12,1:50-52,1:7“. Wenn Sie tatsächlich nicht mehr als 1 CPU-Gruppe haben, können Sie diese Einstellung nicht verwenden. Sie müssen die Einstellung Maske zuordnen verwenden. Und die von Ihnen angegebenen Zahlen befinden sich innerhalb dieser Gruppe. Das bedeutet, dass >= 64 nicht möglich ist.
Bei Linux-Betriebssystemen, bei denen das Konzept der CPU-Gruppe nicht vorhanden ist, können Sie diese Einstellung und die Einstellung Maske zuordnen verwenden, um dieselben Bereiche anzugeben. Geben Sie „1-10“ anstelle von „0:1-10“ an, da Sie keinen Gruppenindex angeben müssen.
Wenn die GC-Prozessoraffinität deaktiviert ist, wird diese Einstellung ignoriert.
Gilt nur für die Garbage Collection des Servers.
Weitere Informationen finden Sie unter Optimieren der CPU-Konfiguration für GC auf Computern mit mehr als 64 CPUs im Blog von Maoni Stephens.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.HeapAffinitizeRanges`	Durch Kommas getrennte Liste mit Prozessornummern oder Bereichen von Prozessornummern Unix-Beispiel: „1-10,12,50-52,70“ Windows-Beispiel: „0:1-10,0:12,1:50-52,1:7“	.NET Core 3.0
Umgebungsvariable	`COMPlus_GCHeapAffinitizeRanges`	Durch Kommas getrennte Liste mit Prozessornummern oder Bereichen von Prozessornummern Unix-Beispiel: „1-10,12,50-52,70“ Windows-Beispiel: „0:1-10,0:12,1:50-52,1:7“	.NET Core 3.0
Umgebungsvariable	`DOTNET_GCHeapAffinitizeRanges`	Durch Kommas getrennte Liste mit Prozessornummern oder Bereichen von Prozessornummern Unix-Beispiel: „1-10,12,50-52,70“ Windows-Beispiel: „0:1-10,0:12,1:50-52,1:7“	.NET 6

Beispiele

runtimeconfig.json-Datei:

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.HeapAffinitizeRanges": "0:1-10,0:12,1:50-52,1:7"
      }
   }
}

runtimeconfig.template.json-Datei:

{
   "configProperties": {
      "System.GC.HeapAffinitizeRanges": "0:1-10,0:12,1:50-52,1:7"
   }
}

CPU-Gruppen

Konfiguriert, ob der Garbage Collector CPU-Gruppen verwendet

Wenn ein 64-Bit-Windows-Computer über mehrere CPU-Gruppen verfügt, d. h. mehr als 64 Prozessoren vorhanden sind, dann wird durch die Aktivierung dieses Elements die Garbage Collection in allen CPU-Gruppen erweitert. Der Garbage Collector verwendet alle Kerne zum Erstellen und Ausgleichen von Heaps.

Hinweis

Dieses Konzept ist nur unter Windows verfügbar. In älteren Windows-Versionen beschränkte Windows einen Prozess auf eine CPU-Gruppe. Daher hat GC nur eine CPU-Gruppe verwendet, es sei denn, Sie haben diese Einstellung verwendet, um mehrere CPU-Gruppen zu ermöglichen. Diese Betriebssystembeschränkung wurde in Windows 11 und Server 2022 aufgehoben. Ab .NET 7 verwendet GC standardmäßig außerdem alle CPU-Gruppen bei Ausführung unter Windows 11 oder Server 2022.
Gilt nur für Garbage Collection des Servers auf 64-Bit-Windows-Betriebssystemen.
Standard: GC wird nicht über CPU-Gruppen hinweg erweitert. Dies entspricht der Einstellung des Werts auf 0.
Weitere Informationen finden Sie unter Optimieren der CPU-Konfiguration für GC auf Computern mit mehr als 64 CPUs im Blog von Maoni Stephens.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.CpuGroup`	`false` – deaktiviert `true` – aktiviert	.NET 5
Umgebungsvariable	`COMPlus_GCCpuGroup`	`0` – deaktiviert `1` – aktiviert	.NET Core 1.0
Umgebungsvariable	`DOTNET_GCCpuGroup`	`0` – deaktiviert `1` – aktiviert	.NET 6
app.config für .NET Framework	GCCpuGroup	`false` – deaktiviert `true` – aktiviert

Hinweis

Aktivieren Sie die Option Thread_UseAllCpuGroups-Element, um die Common Language Runtime (CLR) so zu konfigurieren, dass auch Threads aus dem Threadpool in allen CPU-Gruppen verteilt werden. Für .NET Core-Apps können Sie diese Option aktivieren, indem Sie den Wert der Umgebungsvariablen DOTNET_Thread_UseAllCpuGroups auf 1 setzen.

Zuordnen

Gibt an, ob Garbage-Collection-Threads Prozessoren zugeordnet werden sollen. Einen GC-Thread zuzuordnen, bedeutet, dass dieser nur auf der jeweiligen CPU ausgeführt werden kann. Für jeden GC-Thread wird ein Heap erstellt.
Gilt nur für die Garbage Collection des Servers.
Standard: Garbage Collection-Threads werden Prozessoren zugeordnet. Dies entspricht der Einstellung des Werts auf false.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.NoAffinitize`	`false` – zuordnen `true` – nicht zuordnen	.NET Core 3.0
Umgebungsvariable	`COMPlus_GCNoAffinitize`	`0` – zuordnen `1` – nicht zuordnen	.NET Core 3.0
Umgebungsvariable	`DOTNET_GCNoAffinitize`	`0` – zuordnen `1` – nicht zuordnen	.NET 6
app.config für .NET Framework	GCNoAffinitize	`false` – zuordnen `true` – nicht zuordnen	.NET Framework 4.6.2

Beispiele

runtimeconfig.json-Datei:

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.NoAffinitize": true
      }
   }
}

runtimeconfig.template.json-Datei:

{
   "configProperties": {
      "System.GC.NoAffinitize": true
   }
}

Heap hard limit

Die heap hard limit is defined as the maximum commit size, in bytes, for the GC heap and GC bookkeeping.
Diese Einstellung gilt nur für 64-Bit-Computer.
Wenn dieser Grenzwert nicht konfiguriert ist, aber der Prozess in einer speicherbeschränkten Umgebung ausgeführt wird, d. h. innerhalb eines Containers mit einem angegebenen Speicherlimit, wird ein Standardwert festgelegt. Dieser Standardwert ist größer als 20 MB oder 75 % des Speicherlimits für den Container.
Diese Einstellung wird ignoriert, wenn die Hardlimits für "Pro-Objekt-Heap" konfiguriert sind.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.HeapHardLimit`	Dezimalwert	.NET Core 3.0
Umgebungsvariable	`COMPlus_GCHeapHardLimit`	Hexadezimalwert	.NET Core 3.0
Umgebungsvariable	`DOTNET_GCHeapHardLimit`	Hexadezimalwert	.NET 6

Beispiele

runtimeconfig.json-Datei:

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.HeapHardLimit": 209715200
      }
   }
}

runtimeconfig.template.json-Datei:

{
   "configProperties": {
      "System.GC.HeapHardLimit": 209715200
   }
}

Tipp

Wenn Sie die Option in runtimeconfig.json festlegen, geben Sie einen Dezimalwert an. Wenn Sie die Option als Umgebungsvariable festlegen, geben Sie einen Hexadezimalwert an. Wenn Sie beispielsweise eine feste Heapgrenze von 200 MiB festlegen, würden die Werte für die JSON-Datei 209715200 und für die Umgebungsvariable 0xc800000 oder C800000 betragen.

Heap hard limit percent

Gibt die heap hard limit as a percentage of the total physical memory. Wenn der Prozess in einer speicherbeschränkten Umgebung ausgeführt wird, d. a. innerhalb eines Containers mit einem angegebenen Speichergrenzwert, ist der gesamte physische Arbeitsspeicher die Speichergrenze. andernfalls steht es auf dem Computer zur Verfügung.
Diese Einstellung gilt nur für 64-Bit-Computer.
Diese Einstellung wird ignoriert, wenn die Heap-Heap-Hardlimits pro Objekt konfiguriert sind oder die Heap hard limit konfiguriert ist.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.HeapHardLimitPercent`	Dezimalwert	.NET Core 3.0
Umgebungsvariable	`COMPlus_GCHeapHardLimitPercent`	Hexadezimalwert	.NET Core 3.0
Umgebungsvariable	`DOTNET_GCHeapHardLimitPercent`	Hexadezimalwert	.NET 6

Beispiele

runtimeconfig.json-Datei:

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.HeapHardLimitPercent": 30
      }
   }
}

runtimeconfig.template.json-Datei:

{
   "configProperties": {
      "System.GC.HeapHardLimitPercent": 30
   }
}

Tipp

Wenn Sie die Option in runtimeconfig.json festlegen, geben Sie einen Dezimalwert an. Wenn Sie die Option als Umgebungsvariable festlegen, geben Sie einen Hexadezimalwert an. Beispielsweise würden bei einer Begrenzung des Heapverbrauchs auf 30 % die Werte für die JSON-Datei 30 und für die Umgebungsvariable 0x1E oder 1E betragen.

Feste Grenzen pro Objekt heap

Sie können den Heap-Heap-Grenzwert des GC pro Objekt-Heap-Basis angeben. Die verschiedenen Arten von Heaps sind: große Objektheaps (Large Object Heap, LOH), kleine Objektheaps (Small Object Heap, SOH) und fixierte Objektheaps (Pinned Object Heap, POH).

Wenn Sie für eine der Einstellungen DOTNET_GCHeapHardLimitSOH, DOTNET_GCHeapHardLimitLOH oder DOTNET_GCHeapHardLimitPOH einen Wert angeben, müssen Sie auch einen Wert für DOTNET_GCHeapHardLimitSOH und DOTNET_GCHeapHardLimitLOH angeben. Andernfalls kann die Laufzeit nicht initialisiert werden.
Der Standardwert für DOTNET_GCHeapHardLimitPOH ist 0. DOTNET_GCHeapHardLimitSOH und DOTNET_GCHeapHardLimitLOH verfügen über keine Standardwerte.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.HeapHardLimitSOH`	Dezimalwert	.NET 5
Umgebungsvariable	`COMPlus_GCHeapHardLimitSOH`	Hexadezimalwert	.NET 5
Umgebungsvariable	`DOTNET_GCHeapHardLimitSOH`	Hexadezimalwert	.NET 6

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.HeapHardLimitLOH`	Dezimalwert	.NET 5
Umgebungsvariable	`COMPlus_GCHeapHardLimitLOH`	Hexadezimalwert	.NET 5
Umgebungsvariable	`DOTNET_GCHeapHardLimitLOH`	Hexadezimalwert	.NET 6

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.HeapHardLimitPOH`	Dezimalwert	.NET 5
Umgebungsvariable	`COMPlus_GCHeapHardLimitPOH`	Hexadezimalwert	.NET 5
Umgebungsvariable	`DOTNET_GCHeapHardLimitPOH`	Hexadezimalwert	.NET 6

Diese Konfigurationseinstellungen verfügen nicht über bestimmte MSBuild-Eigenschaften. Sie können jedoch stattdessen ein RuntimeHostConfigurationOption-MSBuild-Element hinzufügen. Verwenden Sie den Einstellungsnamen runtimeconfig.json als Wert des Include-Attributs. Ein Beispiel finden Sie unter MSBuild-Eigenschaften.

Tipp

Wenn Sie die Option in runtimeconfig.json festlegen, geben Sie einen Dezimalwert an. Wenn Sie die Option als Umgebungsvariable festlegen, geben Sie einen Hexadezimalwert an. Wenn Sie beispielsweise eine feste Heapgrenze von 200 MiB festlegen, würden die Werte für die JSON-Datei 209715200 und für die Umgebungsvariable 0xc800000 oder C800000 betragen.

Feste Prozentsätze pro Objekt heap

Wenn Sie für eine der Einstellungen DOTNET_GCHeapHardLimitSOHPercent, DOTNET_GCHeapHardLimitLOHPercent oder DOTNET_GCHeapHardLimitPOHPercent einen Wert angeben, müssen Sie auch einen Wert für DOTNET_GCHeapHardLimitSOHPercent und DOTNET_GCHeapHardLimitLOHPercent angeben. Andernfalls kann die Laufzeit nicht initialisiert werden.
Diese Einstellungen werden ignoriert, wenn DOTNET_GCHeapHardLimitSOH, DOTNET_GCHeapHardLimitLOH und DOTNET_GCHeapHardLimitPOH angegeben sind.
Der Wert 1 bedeutet, dass die Garbage Collection 1 % des gesamten physischen Speichers für diesen Objektheap verwendet.
Jeder Wert muss größer als 0 (null) und kleiner als 100 sein. Außerdem muss die Summe der drei Prozentwerte kleiner als 100 sein. Andernfalls tritt ein Fehler bei der Initialisierung der Laufzeit auf.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.HeapHardLimitSOHPercent`	Dezimalwert	.NET 5
Umgebungsvariable	`COMPlus_GCHeapHardLimitSOHPercent`	Hexadezimalwert	.NET 5
Umgebungsvariable	`DOTNET_GCHeapHardLimitSOHPercent`	Hexadezimalwert	.NET 6

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.HeapHardLimitLOHPercent`	Dezimalwert	.NET 5
Umgebungsvariable	`COMPlus_GCHeapHardLimitLOHPercent`	Hexadezimalwert	.NET 5
Umgebungsvariable	`DOTNET_GCHeapHardLimitLOHPercent`	Hexadezimalwert	.NET 6

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.HeapHardLimitPOHPercent`	Dezimalwert	.NET 5
Umgebungsvariable	`COMPlus_GCHeapHardLimitPOHPercent`	Hexadezimalwert	.NET 5
Umgebungsvariable	`DOTNET_GCHeapHardLimitPOHPercent`	Hexadezimalwert	.NET 6

Tipp

Wenn Sie die Option in runtimeconfig.json festlegen, geben Sie einen Dezimalwert an. Wenn Sie die Option als Umgebungsvariable festlegen, geben Sie einen Hexadezimalwert an. Beispielsweise würden bei einer Begrenzung des Heapverbrauchs auf 30 % die Werte für die JSON-Datei 30 und für die Umgebungsvariable 0x1E oder 1E betragen.

Hohe Speicherauslastung (Prozent)

Die Arbeitsspeicherauslastung wird durch den Prozentsatz des verwendeten physischen Speichers angegeben. Wenn die physische Arbeitsspeicherauslastung 90 % erreicht, wird die Garbage Collection standardmäßig aggressiver, um vollständige, komprimierende Garbage Collection-Vorgänge durchzuführen, um Auslagerungsvorgänge zu vermeiden. Wenn die Arbeitsspeicherauslastung unter 90 % liegt, bevorzugt GC Hintergrundsammlungen für vollständige Garbage Collections, die kürzere Pausen aufweisen, aber die Gesamtheapgröße nicht wesentlich verringern. Auf Computern mit einer beträchtlichen Menge an Arbeitsspeicher (80 GB oder mehr) liegt der Standardwert für die Auslastung zwischen 90 % und 97 %.

Der Schwellenwert für hohe Arbeitsspeicherauslastung kann durch die Umgebungsvariable DOTNET_GCHighMemPercent oder die JSON-Konfigurationseinstellung System.GC.HighMemoryPercent angepasst werden. Wenn Sie die Heapgröße steuern möchten, sollten Sie den Schwellenwert anpassen. Beispielsweise ist es für den vorherrschenden Prozess auf einem Computer mit 64 GB Arbeitsspeicher sinnvoll, dass GC zu reagieren beginnt, wenn 10 % des Arbeitsspeichers verfügbar sind. Für kleinere Prozesse (z. B. für einen Prozess, der nur 1 GB Arbeitsspeicher verbraucht) kann GC bequem mit weniger als 10 % des verfügbaren Speichers ausgeführt werden. Für diese kleineren Prozesse sollten Sie den Schwellenwert auf einen höheren Wert festlegen. Wenn andererseits größere Prozesse kleinere Heapgrößen haben sollen (auch wenn genügend physischer Arbeitsspeicher verfügbar ist), ist die Herabsetzung dieses Schwellenwerts eine effektive Methode, mit der GC schneller reagieren kann, um den Heap zu komprimieren.

Hinweis

Bei Prozessen, die in einem Container ausgeführt werden, berücksichtigt GC den physischen Arbeitsspeicher basierend auf dem Containergrenzwert.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.HighMemoryPercent`	Dezimalwert	.NET 5
Umgebungsvariable	`COMPlus_GCHighMemPercent`	Hexadezimalwert	.NET Core 3.0 .NET Framework 4.7.2
Umgebungsvariable	`DOTNET_GCHighMemPercent`	Hexadezimalwert	.NET 6

Tipp

Wenn Sie die Option in runtimeconfig.json festlegen, geben Sie einen Dezimalwert an. Wenn Sie die Option als Umgebungsvariable festlegen, geben Sie einen Hexadezimalwert an. Wenn Sie beispielsweise den Schwellenwert für hohe Arbeitsspeicherauslastung auf 75 % festlegen, würden die Werte für die JSON-Datei 75 und für die Umgebungsvariable 0x4B oder 4B betragen.

VM beibehalten

Konfiguriert, ob Segmente, die gelöscht werden sollen, zur späteren Verwendung auf eine Standbyliste aufgenommen oder an das Betriebssystem zurückgegeben werden
Standard: Segmente werden an das Betriebssystem zurückgegeben. Dies entspricht der Einstellung des Werts auf false.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.RetainVM`	`false` – Freigabe an Betriebssystem `true` – in Standbymodus versetzen	.NET Core 1.0
MSBuild-Eigenschaft	`RetainVMGarbageCollection`	`false` – Freigabe an Betriebssystem `true` – in Standbymodus versetzen	.NET Core 1.0
Umgebungsvariable	`COMPlus_GCRetainVM`	`0` – Freigabe an Betriebssystem `1` – in Standbymodus versetzen	.NET Core 1.0
Umgebungsvariable	`DOTNET_GCRetainVM`	`0` – Freigabe an Betriebssystem `1` – in Standbymodus versetzen	.NET 6

Beispiele

runtimeconfig.json-Datei:

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.RetainVM": true
      }
   }
}

runtimeconfig.template.json-Datei:

{
   "configProperties": {
      "System.GC.RetainVM": true
   }
}

Projektdatei:

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <RetainVMGarbageCollection>true</RetainVMGarbageCollection>
  </PropertyGroup>

</Project>

Umfangreiche Seiten

Gibt an, ob umfangreiche Seiten verwendet werden sollen, wenn eine feste Heapgrenze festgelegt wird
Standard: Verwenden Sie keine großen Seiten, wenn eine feste Heapgrenze festgelegt ist. Dies entspricht der Einstellung des Werts auf 0.
Dies ist eine experimentelle Einstellung.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	Nicht zutreffend	–	Nicht zutreffend
Umgebungsvariable	`COMPlus_GCLargePages`	`0` – deaktiviert `1` – aktiviert	.NET Core 3.0
Umgebungsvariable	`DOTNET_GCLargePages`	`0` – deaktiviert `1` – aktiviert	.NET 6

Große Objekte zulassen

Konfiguriert die Garbage-Collector-Unterstützung auf 64-Bit-Plattformen für Arrays mit einer Gesamtgröße von mehr als 2 Gigabytes (GB)
Standard: GC unterstützt Arrays, die größer als 2 GB sind. Dies entspricht der Einstellung des Werts auf 1.
Diese Option wird in einer zukünftigen Version von .NET möglicherweise veraltet sein.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	Nicht zutreffend	–	Nicht zutreffend
Umgebungsvariable	`COMPlus_gcAllowVeryLargeObjects`	`1` – aktiviert `0` – deaktiviert	.NET Core 1.0
Umgebungsvariable	`DOTNET_gcAllowVeryLargeObjects`	`1` – aktiviert `0` – deaktiviert	.NET 6
app.config für .NET Framework	gcAllowVeryLargeObjects	`1` – aktiviert `0` – deaktiviert	.NET Framework 4.5

Großer Objektheapschwellenwert

Gibt die Größe des Schwellenwerts in Bytes an, der bewirkt, dass Objekte auf den großen Objektheap (Large Object Heap, LOH) gehen
Der Standardschwellenwert beträgt 85.000 Bytes.
Der von Ihnen festgelegte Wert muss größer sein als der Standardschwellenwert.
Der Wert kann von der Laufzeit auf die maximal mögliche Größe für die aktuelle Konfiguration begrenzt werden. Sie können den zur Laufzeit verwendeten Wert über die GC.GetConfigurationVariables() API prüfen.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.LOHThreshold`	Dezimalwert	.NET Core 1.0
Umgebungsvariable	`COMPlus_GCLOHThreshold`	Hexadezimalwert	.NET Core 1.0
Umgebungsvariable	`DOTNET_GCLOHThreshold`	Hexadezimalwert	.NET 6
app.config für .NET Framework	GCLOHThreshold	Dezimalwert	.NET Framework 4.8

Beispiele

runtimeconfig.json-Datei:

{
   "runtimeOptions": {
      "configProperties": {
         "System.GC.LOHThreshold": 120000
      }
   }
}

runtimeconfig.template.json-Datei:

{
   "configProperties": {
      "System.GC.LOHThreshold": 120000
   }
}

Tipp

Wenn Sie die Option in runtimeconfig.json festlegen, geben Sie einen Dezimalwert an. Wenn Sie die Option als Umgebungsvariable festlegen, geben Sie einen Hexadezimalwert an. Wenn Sie beispielsweise die Größe eines Schwellenwerts auf 120.000 Bytes festlegen, würden die Werte für die JSON-Datei 120000 und für die Umgebungsvariable 0x1D4C0 oder 1D4C0 betragen.

Eigenständige GC

Um einen eigenständigen Garbage Collector anstelle der Standard-GC-Implementierung zu verwenden, können Sie entweder den Pfad (in .NET 9 und höher) oder den Namen einer systemeigenen GC-Bibliothek angeben.

Pfad

Gibt den vollständigen Pfad einer systemeigenen GC-Bibliothek an, die von der Laufzeit anstelle der Standard-GC-Implementierung geladen wird. Um sicher zu sein, sollte dieser Speicherort vor potenziell böswilligen Manipulationen geschützt werden.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.Path`	string_path	.NET 9
Umgebungsvariable	`DOTNET_GCPath`	string_path	.NET 9

Name

Gibt den Namen einer systemeigenen GC-Bibliothek an, die von der Runtime anstelle der Standard-GC-Implementierung geladen wird. Das Verhalten wurde in .NET 9 mit der Einführung der Pfadkonfiguration geändert.

In .NET 8 und früheren Versionen:
- Wenn nur ein Name der Bibliothek angegeben ist, muss sich die Bibliothek im selben Verzeichnis wie die .NET-Laufzeit befinden (coreclr.dll unter Windows, libcoreclr.so unter Linux oder libcoreclr.dylib unter OSX).
- Der Wert kann auch ein relativer Pfad sein, z. B. wenn Sie "." angeben. \clrgc.dll" unter Windows wird clrgc.dll aus dem übergeordneten Verzeichnis des .NET-Laufzeitverzeichnisses geladen.
In .NET 9 und höheren Versionen gibt dieser Wert nur einen Dateinamen an (Pfade sind nicht zulässig):
- .NET sucht nach dem Namen, den Sie im Verzeichnis angeben, in dem sich die Assembly befindet, die die App-Methode Main enthält.
- Wenn die Datei nicht gefunden wird, wird das .NET-Laufzeitverzeichnis durchsucht.
Diese Konfigurationseinstellung wird ignoriert, wenn die Pfadkonfiguration angegeben ist.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.Name`	string_name	.NET 7
Umgebungsvariable	`COMPlus_GCName`	string_name	.NET Core 2.0
Umgebungsvariable	`DOTNET_GCName`	string_name	.NET 6

Sparen von Arbeitsspeicher

Konfiguriert den Garbage Collector für eine geringere Auslastung des Arbeitsspeichers – auf Kosten einer häufigeren Garbage Collection-Ausführung und möglicherweise längeren Wartezeiten.
Der Standardwert ist 0. Dies impliziert keine Änderung.
Neben dem Standardwert 0 sind Werte zwischen 1 und 9 (einschließlich) gültig. Je höher der Wert, desto mehr versucht der Garbage Collector, Arbeitsspeicher zu sparen und somit den Heap klein zu halten.
Wenn der Wert ungleich null ist, wird der große Objektheap automatisch komprimiert, wenn er zu stark fragmentiert ist.

	Einstellungsname	Werte	Eingeführt in Version
runtimeconfig.json	`System.GC.ConserveMemory`	`0` - `9`	.NET 6
Umgebungsvariable	`COMPlus_GCConserveMemory`	`0` -`9`	.NET Framework 4.8
Umgebungsvariable	`DOTNET_GCConserveMemory`	`0` -`9`	.NET 6
app.config für .NET Framework	GCConserveMemory	`0` -`9`	.NET Framework 4.8

Beispiel für die Datei app.config:


<configuration>
  <runtime>
    <GCConserveMemory enabled="5"/>
  </runtime>
</configuration>

Tipp

Experimentieren Sie mit verschiedenen Zahlen, um zu sehen, welcher Wert für Sie am besten geeignet ist. Beginnen Sie mit einem Wert zwischen 5 und 7.

Dynamische Anpassung an Anwendungsgrößen (DATAS)

Konfiguriert den Garbage Collector für die Verwendung von DATAS. DATAS passt sich an die Anforderungen an den Anwendungsspeicher an, d. h. die Größe des App-Heaps sollte ungefähr proportional zur langlebigen Datengröße sein.
Standardmäßig aktiviert, beginnend in .NET 9.

	Einstellungsname	Werte	Eingeführt in Version
Umgebungsvariable	`DOTNET_GCDynamicAdaptationMode`	`1` – aktiviert `0` – deaktiviert	.NET 8
MSBuild-Eigenschaft	`GarbageCollectionAdaptationMode`	`1` – aktiviert `0` – deaktiviert	.NET 8
runtimeconfig.json	`System.GC.DynamicAdaptationMode`	`1` – aktiviert `0` – deaktiviert	.NET 8

Freigeben über

Runtimekonfigurationsoptionen für Garbage Collection

Möglichkeiten zum Angeben der Konfiguration

Varianten der Garbage Collection

Arbeitsstationen und Server im Vergleich

Beispiele

Garbage Collection im Hintergrund

Beispiele

Verwalten des Ressourceneinsatzes

Heapanzahl

Beispiele

Maske zuordnen

Beispiele

Bereiche zuordnen

Beispiele

CPU-Gruppen

Zuordnen

Beispiele

Heap hard limit

Beispiele

Heap hard limit percent

Beispiele

Feste Grenzen pro Objekt heap

Feste Prozentsätze pro Objekt heap

Hohe Speicherauslastung (Prozent)

VM beibehalten

Beispiele

Umfangreiche Seiten

Große Objekte zulassen

Großer Objektheapschwellenwert

Beispiele

Eigenständige GC

Pfad

Name

Sparen von Arbeitsspeicher

Dynamische Anpassung an Anwendungsgrößen (DATAS)

Zusätzliche Ressourcen