GC.GetGeneration Méthode

  • Référence

Définition

Espace de noms:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Retourne le numéro de la génération actuelle d'un objet.

Surcharges

GetGeneration(Object)

Retourne le numéro de la génération actuelle de l'objet spécifié.
GetGeneration(WeakReference)

Retourne le numéro de la génération actuelle de la cible d'une référence faible spécifiée.

GetGeneration(Object)

Source:
GC.cs
Source:
GC.cs
Source:
GC.cs

Retourne le numéro de la génération actuelle de l'objet spécifié.

public:
 static int GetGeneration(System::Object ^ obj);
public static int GetGeneration (object obj);
static member GetGeneration : obj -> int
Public Shared Function GetGeneration (obj As Object) As Integer

Paramètres

obj
Object

Objet pour lequel les informations de génération sont récupérées.

Retours

Int32

Numéro de génération actuel de obj, ou Int32.MaxValue.

Exemples

L’exemple suivant montre comment utiliser la GetGeneration méthode pour déterminer l’âge d’un objet. L’exemple effectue ensuite des collectes de mémoires pour propre la mémoire et comparer les totaux de mémoire avant et après la collecte dans la console.

using namespace System;
const long maxGarbage = 1000;
ref class MyGCCollectClass
{
public:
   void MakeSomeGarbage()
   {
      Version^ vt;
      for ( int i = 0; i < maxGarbage; i++ )
      {
         
         // Create objects and release them to fill up memory
         // with unused objects.
         vt = gcnew Version;

      }
   }

};

int main()
{
   MyGCCollectClass^ myGCCol = gcnew MyGCCollectClass;
   
   // Determine the maximum number of generations the system
   // garbage collector currently supports.
   Console::WriteLine( "The highest generation is {0}", GC::MaxGeneration );
   myGCCol->MakeSomeGarbage();
   
   // Determine which generation myGCCol object is stored in.
   Console::WriteLine( "Generation: {0}", GC::GetGeneration( myGCCol ) );
   
   // Determine the best available approximation of the number
   // of bytes currently allocated in managed memory.
   Console::WriteLine( "Total Memory: {0}", GC::GetTotalMemory( false ) );
   
   // Perform a collection of generation 0 only.
   GC::Collect( 0 );
   
   // Determine which generation myGCCol object is stored in.
   Console::WriteLine( "Generation: {0}", GC::GetGeneration( myGCCol ) );
   Console::WriteLine( "Total Memory: {0}", GC::GetTotalMemory( false ) );
   
   // Perform a collection of all generations up to and including 2.
   GC::Collect( 2 );
   
   // Determine which generation myGCCol object is stored in.
   Console::WriteLine( "Generation: {0}", GC::GetGeneration( myGCCol ) );
   Console::WriteLine( "Total Memory: {0}", GC::GetTotalMemory( false ) );
}

using System;

namespace GCCollectIntExample
{
    class MyGCCollectClass
    {
        private const long maxGarbage = 1000;

        static void Main()
        {
            MyGCCollectClass myGCCol = new MyGCCollectClass();

            // Determine the maximum number of generations the system
        // garbage collector currently supports.
            Console.WriteLine("The highest generation is {0}", GC.MaxGeneration);

            myGCCol.MakeSomeGarbage();

            // Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol));

            // Determine the best available approximation of the number
        // of bytes currently allocated in managed memory.
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));

            // Perform a collection of generation 0 only.
            GC.Collect(0);

            // Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol));

            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));

            // Perform a collection of all generations up to and including 2.
            GC.Collect(2);

            // Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol));
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(false));
            Console.Read();
        }

        void MakeSomeGarbage()
        {
            Version vt;

            for(int i = 0; i < maxGarbage; i++)
            {
                // Create objects and release them to fill up memory
        // with unused objects.
                vt = new Version();
            }
        }
    }
}

open System

let maxGarbage = 1000

type MyGCCollectClass() =
    member _.MakeSomeGarbage() =
        for _ = 1 to maxGarbage do
            // Create objects and release them to fill up memory with unused objects.
            Version() |> ignore

[<EntryPoint>]
let main _ =
    let myGCCol = MyGCCollectClass()

    // Determine the maximum number of generations the system
    // garbage collector currently supports.
    printfn $"The highest generation is {GC.MaxGeneration}"

    myGCCol.MakeSomeGarbage()

    // Determine which generation myGCCol object is stored in.
    printfn $"Generation: {GC.GetGeneration myGCCol}"

    // Determine the best available approximation of the number
    // of bytes currently allocated in managed memory.
    printfn $"Total Memory: {GC.GetTotalMemory false}"

    // Perform a collection of generation 0 only.
    GC.Collect 0

    // Determine which generation myGCCol object is stored in.
    printfn $"Generation: {GC.GetGeneration myGCCol}"

    printfn $"Total Memory: {GC.GetTotalMemory false}"

    // Perform a collection of all generations up to and including 2.
    GC.Collect 2

    // Determine which generation myGCCol object is stored in.
    printfn $"Generation: {GC.GetGeneration myGCCol}"
    printfn $"Total Memory: {GC.GetTotalMemory false}"

    0

Namespace GCCollectInt_Example
    Class MyGCCollectClass
        Private maxGarbage As Long = 10000

        Public Shared Sub Main()
            Dim myGCCol As New MyGCCollectClass

            'Determine the maximum number of generations the system
            'garbage collector currently supports.
            Console.WriteLine("The highest generation is {0}", GC.MaxGeneration)

            myGCCol.MakeSomeGarbage()

            'Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol))

            'Determine the best available approximation of the number 
            'of bytes currently allocated in managed memory.
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(False))

            'Perform a collection of generation 0 only.
            GC.Collect(0)

            'Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol))

            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(False))

            'Perform a collection of all generations up to and including 2.
            GC.Collect(2)

            'Determine which generation myGCCol object is stored in.
            Console.WriteLine("Generation: {0}", GC.GetGeneration(myGCCol))
            Console.WriteLine("Total Memory: {0}", GC.GetTotalMemory(False))
            Console.Read()

        End Sub


        Sub MakeSomeGarbage()
            Dim vt As Version

            Dim i As Integer
            For i = 0 To maxGarbage - 1
                'Create objects and release them to fill up memory
                'with unused objects.
                vt = New Version
            Next i
        End Sub
    End Class
End Namespace

Remarques

Utilisez cette méthode pour déterminer l’âge d’un objet, puis utilisez ces informations avec la Collect méthode pour forcer le garbage collector à collecter des objets dans la même génération. Par exemple, utilisez cette méthode lorsque vous avez un ensemble d’objets qui sont créés en tant que groupe et qui deviennent inaccessibles en même temps.

À compter de .NET 8, cette méthode peut retourner MaxValue des objets alloués sur des tas non GC. Pour plus d’informations, consultez GC. GetGeneration peut retourner Int32.MaxValue.

Voir aussi

S’applique à

GetGeneration(WeakReference)

Source:
GC.CoreCLR.cs
Source:
GC.CoreCLR.cs
Source:
GC.CoreCLR.cs

Retourne le numéro de la génération actuelle de la cible d'une référence faible spécifiée.

public:
 static int GetGeneration(WeakReference ^ wo);
public static int GetGeneration (WeakReference wo);
static member GetGeneration : WeakReference -> int
Public Shared Function GetGeneration (wo As WeakReference) As Integer

Paramètres

wo
WeakReference

WeakReference qui fait référence à l'objet cible dont le numéro de génération doit être déterminé.

Retours

Int32

Numéro de génération actuel de la cible de wo, ou MaxValue.

Exceptions

ArgumentException

Le garbage collection a déjà été exécuté sur wo.

ArgumentNullException

La cible de la référence faible a déjà été ramassée.

Exemples

L’exemple suivant illustre l’utilisation de la GetGeneration méthode pour déterminer l’âge d’un objet de référence faible.

using namespace System;
ref class MyGCCollectClass
{
private:
   static const long maxGarbage = 1000;

public:
   void MakeSomeGarbage()
   {
      Version^ vt;
      for ( int i = 0; i < maxGarbage; i++ )
      {
         
         // Create objects and release them to fill up memory
         // with unused objects.
         vt = gcnew Version;

      }
   }

};

int main()
{
   
   // Create a strong reference to an Object.
   MyGCCollectClass^ myGCCol = gcnew MyGCCollectClass;
   
   // Put some objects in memory.
   myGCCol->MakeSomeGarbage();
   
   // Get the generation of managed memory where myGCCol is stored.
   Console::WriteLine( "The object is in generation: {0}", GC::GetGeneration( myGCCol ) );
   
   // Perform a full garbage collection.
   // Because there is a strong reference to myGCCol, it will
   // not be garbage collected.
   GC::Collect();
   
   // Get the generation of managed memory where myGCCol is stored.
   Console::WriteLine( "The object is in generation: {0}", GC::GetGeneration( myGCCol ) );
   
   // Create a WeakReference to myGCCol.
   WeakReference^ wkref = gcnew WeakReference( myGCCol );
   
   // Remove the strong reference to myGCCol.
   myGCCol = nullptr;
   
   // Get the generation of managed memory where wkref is stored.
   Console::WriteLine( "The WeakReference to the object is in generation: {0}", GC::GetGeneration( wkref ) );
   
   // Perform another full garbage collection.
   // A WeakReference will not survive a garbage collection.
   GC::Collect();
   
   // Try to get the generation of managed memory where wkref is stored.
   // Because it has been collected, an exception will be thrown.
   try
   {
      Console::WriteLine( "The WeakReference to the object is in generation: {0}", GC::GetGeneration( wkref ) );
      Console::Read();
   }
   catch ( Exception^ e ) 
   {
      Console::WriteLine( "The WeakReference to the object has been garbage collected: ' {0}'", e );
   }

}

using System;

namespace GCGetGenerationWeakExample
{
    public class MyGCCollectClass
    {
        private const long maxGarbage = 1000;

        static void Main()
        {
            // Create a strong reference to an object.
            MyGCCollectClass myGCCol = new MyGCCollectClass();

            // Put some objects in memory.
            myGCCol.MakeSomeGarbage();

            // Get the generation of managed memory where myGCCol is stored.
            Console.WriteLine("The object is in generation: {0}", GC.GetGeneration(myGCCol));
                        
            // Perform a full garbage collection.
            // Because there is a strong reference to myGCCol, it will
            // not be garbage collected.
            GC.Collect();
            
            // Get the generation of managed memory where myGCCol is stored.
            Console.WriteLine("The object is in generation: {0}", GC.GetGeneration(myGCCol));
            
            // Create a WeakReference to myGCCol.
            WeakReference wkref = new WeakReference(myGCCol);
            // Remove the strong reference to myGCCol.
            myGCCol = null;

            // Get the generation of managed memory where wkref is stored.
            Console.WriteLine("The WeakReference to the object is in generation: {0}", GC.GetGeneration(wkref));
            
            // Perform another full garbage collection.
            // A WeakReference will not survive a garbage collection.
            GC.Collect();
        
            // Try to get the generation of managed memory where wkref is stored.
            // Because it has been collected, an exception will be thrown.
            try
            {
                Console.WriteLine("The WeakReference to the object is in generation: {0}", GC.GetGeneration(wkref));
                Console.Read();
            }
            catch(Exception e)
            {
                Console.WriteLine("The WeakReference to the object has been garbage collected: '{0}'", e);
                Console.Read();
            }
        }

        void MakeSomeGarbage()
        {
            Version vt;

            for(int i = 0; i < maxGarbage; i++)
            {
                // Create objects and release them to fill up memory
                // with unused objects.
                vt = new Version();
            }
        }
    }
}

open System

let maxGarbage = 1000

[<AllowNullLiteral>]
type MyGCCollectClass() =
    member _.MakeSomeGarbage() =
        for i = 1 to maxGarbage do
            // Create objects and release them to fill up memory
            // with unused objects.
            Version() |> ignore

// Create a strong reference to an object.
let mutable myGCCol = MyGCCollectClass()

// Put some objects in memory.
myGCCol.MakeSomeGarbage()

// Get the generation of managed memory where myGCCol is stored.
printfn $"The object is in generation: {GC.GetGeneration myGCCol}"
            
// Perform a full garbage collection.
// Because there is a strong reference to myGCCol, it will
// not be garbage collected.
GC.Collect()

// Get the generation of managed memory where myGCCol is stored.
printfn $"The object is in generation: {GC.GetGeneration myGCCol}"

// Create a WeakReference to myGCCol.
let wkref = WeakReference myGCCol
// Remove the strong reference to myGCCol.
myGCCol <- null

// Get the generation of managed memory where wkref is stored.
printfn $"The WeakReference to the object is in generation: {GC.GetGeneration wkref}"

// Perform another full garbage collection.
// A WeakReference will not survive a garbage collection.
GC.Collect()

// Try to get the generation of managed memory where wkref is stored.
// Because it has been collected, an exception will be thrown.
try
    printfn $"The WeakReference to the object is in generation: {GC.GetGeneration wkref}"
    stdin.Read() |> ignore
with e ->
    printfn $"The WeakReference to the object has been garbage collected: '{e}'"
    stdin.Read() |> ignore

Namespace GCGetGenerationWeakExample

   Class MyGCCollectClass
      Private maxGarbage As Long = 1000

      Public Shared Sub Main()
         ' Create a strong reference to an object.
         Dim myGCCol As New MyGCCollectClass

         ' Put some objects in memory.
         myGCCol.MakeSomeGarbage()

         ' Get the generation of managed memory where myGCCol is stored.
         Console.WriteLine("The object is in generation: {0}", _
                            GC.GetGeneration(myGCCol))

         ' Perform a full garbage collection.
         ' Because there is a strong reference to myGCCol, it will
         ' not be garbage collected.
         GC.Collect()

         ' Get the generation of managed memory where myGCCol is stored.
         Console.WriteLine("The object is in generation: {0}", _
                            GC.GetGeneration(myGCCol))

         ' Create a WeakReference to myGCCol.
         Dim wkref As New WeakReference(myGCCol)
         ' Remove the strong reference to myGCCol.
         myGCCol = Nothing

         ' Get the generation of managed memory where wkref is stored.
         Console.WriteLine("The WeakReference to the object is in generation: {0}", _
                           GC.GetGeneration(wkref))

         ' Perform another full garbage collection.
         ' A WeakReference will not survive a garbage collection.
         GC.Collect()

         ' Try to get the generation of managed memory where wkref is stored.
         ' Because it has been collected, an exception will be thrown.
         Try
            Console.WriteLine("The WeakReference to the object is in generation: {0}", _
                               GC.GetGeneration(wkref))
            Console.Read()
         Catch e As Exception
            Console.WriteLine("The WeakReference to the object " & _
                              "has been garbage collected: '{0}'", e)
            Console.Read()
         End Try
      End Sub


      Sub MakeSomeGarbage()
         Dim vt As Version

         Dim i As Integer
         For i = 0 To maxGarbage - 1
            ' Create objects and release them to fill up memory
            ' with unused objects.
            vt = New Version
         Next i
      End Sub
   End Class
End Namespace

Remarques

À compter de .NET 8, cette méthode peut retourner MaxValue des objets alloués sur des tas non GC. Pour plus d’informations, consultez GC. GetGeneration peut retourner Int32.MaxValue.

Voir aussi

S’applique à