Uređivanje

Dijeli putem


GC.GetGeneration Method

Definition

Returns the current generation number of an object.

Overloads

GetGeneration(Object)

Returns the current generation number of the specified object.

GetGeneration(WeakReference)

Returns the current generation number of the target of a specified weak reference.

GetGeneration(Object)

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

Returns the current generation number of the specified object.

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

Parameters

obj
Object

The object that generation information is retrieved for.

Returns

The current generation number of obj, or Int32.MaxValue.

Examples

The following example demonstrates how to use the GetGeneration method to determine the age of an object. The example then performs garbage collections to clean up memory and compare the pre and post collection memory totals in the 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

Remarks

Use this method to determine the age of an object, and then use that information with the Collect method to force the garbage collector to collect objects in the same generation. For example, use this method when you have a set of objects that are created as a group and that become inaccessible at the same time.

Starting in .NET 8, this method might return MaxValue for objects allocated on non-GC heaps. For more information, see GC.GetGeneration might return Int32.MaxValue.

See also

Applies to

GetGeneration(WeakReference)

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

Returns the current generation number of the target of a specified weak reference.

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

Parameters

wo
WeakReference

A WeakReference that refers to the target object whose generation number is to be determined.

Returns

The current generation number of the target of wo, or MaxValue.

Exceptions

Garbage collection has already been performed on wo.

The target of the weak reference has already been garbage collected.

Examples

The following example demonstrates the use of the GetGeneration method to determine the age of a weak reference object.

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

Remarks

Starting in .NET 8, this method might return MaxValue for objects allocated on non-GC heaps. For more information, see GC.GetGeneration might return Int32.MaxValue.

See also

Applies to