StackFrame Classe

Definizione

Spazio dei nomi:

System.Diagnostics

Assembly:

System.Diagnostics.StackTrace.dll

Origine:

StackFrame.cs

Fornisce informazioni su un oggetto StackFrame che rappresenta una chiamata a una funzione sullo stack di chiamate per il thread corrente.

C#

public class StackFrame

Ereditarietà

Object

StackFrame

Esempio

Nell'esempio StackFrame seguente viene illustrato l'uso della classe per fornire le informazioni sul frame dello stack per una traccia dello stack.

C#

using System;
using System.Diagnostics;

namespace StackFrameExample
{
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Method1();
            }
            catch (Exception e)
            {
                StackTrace st = new StackTrace();
                StackTrace st1 = new StackTrace(new StackFrame(true));
                Console.WriteLine(" Stack trace for Main: {0}",
                   st1.ToString());
                Console.WriteLine(st.ToString());
            }
            Console.WriteLine("Press Enter to exit.");
            Console.ReadLine();
        }
        private static void Method1()
        {
            try
            {
                Method2(4);
            }
            catch (Exception e)
            {
                StackTrace st = new StackTrace();
                StackTrace st1 = new StackTrace(new StackFrame(true));
                Console.WriteLine(" Stack trace for Method1: {0}",
                   st1.ToString());
                Console.WriteLine(st.ToString());
                // Build a stack trace for the next frame.
                StackTrace st2 = new StackTrace(new StackFrame(1, true));
                Console.WriteLine(" Stack trace for next level frame: {0}",
                   st2.ToString());
                throw e;
            }
        }
        private static void Method2( int count)
        {
            try
            {
                if (count < 5)
                    throw new ArgumentException("count too large", "count");
            }
            catch (Exception e)
            {
                StackTrace st = new StackTrace();
                StackTrace st1 = new StackTrace(new StackFrame(2,true));
                Console.WriteLine(" Stack trace for Method2: {0}",
                   st1.ToString());
                Console.WriteLine(st.ToString());
                throw e;
            }
        }
    }
}

Nell'esempio seguente viene illustrato l'uso dei membri della StackFrame classe.

C#

using System;
using System.Diagnostics;

using SampleInternal;

namespace SamplePublic
{
    // This console application illustrates various uses
    // of the StackTrace and StackFrame classes.
    class ConsoleApp
    {
       [STAThread]
       static void Main()
        {
            ClassLevel1 mainClass = new ClassLevel1();

            try {
                mainClass.InternalMethod();
            }
            catch (Exception) {
               Console.WriteLine(" Main method exception handler");

               // Display file and line information, if available.
               StackTrace st = new StackTrace(new StackFrame(true));
               Console.WriteLine(" Stack trace for current level: {0}",
                   st.ToString());
               Console.WriteLine(" File: {0}",
                  st.GetFrame(0).GetFileName());
               Console.WriteLine(" Line Number: {0}",
                   st.GetFrame(0).GetFileLineNumber().ToString());

               Console.WriteLine();
               Console.WriteLine("-------------------------------------------------\n");
            }
        }
    }
}

namespace SampleInternal
{
   public class ClassLevel1
   {
      public void InternalMethod()
      {
         try
         {
            ClassLevel2 nestedClass = new ClassLevel2();
            nestedClass.Level2Method();
         }
         catch (Exception e)
         {
            Console.WriteLine(" InternalMethod exception handler");

            // Build a stack trace from one frame, skipping the
            // current frame and using the next frame.  By
            // default, file and line information are not displayed.
            StackTrace st = new StackTrace(new StackFrame(1));
            Console.WriteLine(" Stack trace for next level frame: {0}",
               st.ToString());
            Console.WriteLine(" Stack frame for next level: ");
            Console.WriteLine("   {0}", st.GetFrame(0).ToString());

            Console.WriteLine(" Line Number: {0}",
               st.GetFrame(0).GetFileLineNumber().ToString());

            Console.WriteLine();
            Console.WriteLine("   ... throwing exception to next level ...");
            Console.WriteLine("-------------------------------------------------\n");
            throw e;
         }
      }
   }

   public class ClassLevel2
   {
      public void Level2Method()
      {
         try
         {
            ClassLevel3 nestedClass = new ClassLevel3();
            nestedClass.Level3Method();
         }
         catch (Exception e)
         {
            Console.WriteLine(" Level2Method exception handler");

            // Display the full call stack at this level.
            StackTrace st1 = new StackTrace(true);
            Console.WriteLine(" Stack trace for this level: {0}",
               st1.ToString());

            // Build a stack trace from one frame, skipping the current
            // frame and using the next frame.
            StackTrace st2 = new StackTrace(new StackFrame(1, true));
            Console.WriteLine(" Stack trace built with next level frame: {0}",
               st2.ToString());

            // Build a stack trace skipping the current frame, and
            // including all the other frames.
            StackTrace st3 = new StackTrace(1, true);
            Console.WriteLine(" Stack trace built from the next level up: {0}",
               st3.ToString());

            Console.WriteLine();
            Console.WriteLine("   ... throwing exception to next level ...");
            Console.WriteLine("-------------------------------------------------\n");
            throw e;
         }
      }
   }

   public class ClassLevel3
   {
      public void Level3Method()
      {
         try
         {
            ClassLevel4 nestedClass = new ClassLevel4();
            nestedClass.Level4Method();
         }
         catch (Exception e)
         {
            Console.WriteLine(" Level3Method exception handler");

            // Build a stack trace from a dummy stack frame.
            // Explicitly specify the source file name and
            // line number.
            StackTrace st = new StackTrace(new StackFrame("source.cs", 60));
            Console.WriteLine(" Stack trace with dummy stack frame: {0}",
                        st.ToString());
            for(int i =0; i< st.FrameCount; i++ )
            {
               // Display the stack frame properties.
               StackFrame sf = st.GetFrame(i);
               Console.WriteLine(" File: {0}", sf.GetFileName());
               Console.WriteLine(" Line Number: {0}",
                  sf.GetFileLineNumber());
               // Note that the column number defaults to zero
               // when not initialized.
               Console.WriteLine(" Column Number: {0}",
                  sf.GetFileColumnNumber());
               if (sf.GetILOffset() != StackFrame.OFFSET_UNKNOWN)
               {
                  Console.WriteLine(" Intermediate Language Offset: {0}",
                     sf.GetILOffset());
               }
               if (sf.GetNativeOffset() != StackFrame.OFFSET_UNKNOWN)
               {
                  Console.WriteLine(" Native Offset: {0}",
                     sf.GetNativeOffset());
               }
            }
            Console.WriteLine();
            Console.WriteLine("   ... throwing exception to next level ...");
            Console.WriteLine("-------------------------------------------------\n");
            throw e;
         }
      }
   }

   public class ClassLevel4
   {
      public void Level4Method()
      {
         try
         {
            ClassLevel5 nestedClass = new ClassLevel5();
            nestedClass.Level5Method();
         }
         catch (Exception e)
         {
            Console.WriteLine(" Level4Method exception handler");

            // Build a stack trace from a dummy stack frame.
            // Explicitly specify the source file name, line number
            // and column number.
            StackTrace st = new StackTrace(new StackFrame("source.cs", 79, 24));
            Console.WriteLine(" Stack trace with dummy stack frame: {0}",
                           st.ToString());

            // Access the StackFrames explicitly to display the file
            // name, line number and column number properties.
            // StackTrace.ToString only includes the method name.
            for(int i =0; i< st.FrameCount; i++ )
            {
               StackFrame sf = st.GetFrame(i);
               Console.WriteLine(" File: {0}", sf.GetFileName());
               Console.WriteLine(" Line Number: {0}",
                  sf.GetFileLineNumber());
               Console.WriteLine(" Column Number: {0}",
                  sf.GetFileColumnNumber());
            }
            Console.WriteLine();
            Console.WriteLine("   ... throwing exception to next level ...");
            Console.WriteLine("-------------------------------------------------\n");
            throw e;
         }
      }
   }

   public class ClassLevel5
   {
      public void Level5Method()
      {
         try
         {
            ClassLevel6 nestedClass = new ClassLevel6();
            nestedClass.Level6Method();
         }
         catch (Exception e)
         {
            Console.WriteLine(" Level5Method exception handler");

            StackTrace st = new StackTrace();

            // Display the most recent function call.
            StackFrame sf = st.GetFrame(0);
            Console.WriteLine();
            Console.WriteLine("  Exception in method: ");
            Console.WriteLine("      {0}", sf.GetMethod());

            if (st.FrameCount >1)
            {
               // Display the highest-level function call
               // in the trace.
               sf = st.GetFrame(st.FrameCount-1);
               Console.WriteLine("  Original function call at top of call stack):");
               Console.WriteLine("      {0}", sf.GetMethod());
            }

            Console.WriteLine();
            Console.WriteLine("   ... throwing exception to next level ...");
            Console.WriteLine("-------------------------------------------------\n");
            throw e;
         }
      }
   }

   public class ClassLevel6
   {
      public void Level6Method()
      {
         throw new Exception("An error occurred in the lowest internal class method.");
      }
   }
}

Commenti

Viene StackFrame creato e eseguito il push nello stack di chiamate per ogni chiamata di funzione effettuata durante l'esecuzione di un thread. Il frame dello stack include sempre informazioni e, facoltativamente, include MethodBase informazioni sul nome del file, sul numero di riga e sul numero di colonna.

StackFrame le informazioni saranno più informative con le configurazioni di compilazione debug. Per impostazione predefinita, le compilazioni di debug includono simboli di debug, mentre le build di versione non vengono eseguite. I simboli di debug contengono la maggior parte del file, il nome del metodo, il numero di riga e le informazioni sulla colonna usate per costruire StackFrame oggetti.

Costruttori

StackFrame()	Inizializza una nuova istanza della classe StackFrame.
StackFrame(Boolean)	Inizializza una nuova istanza della classe StackFrame acquisendo eventualmente informazioni sull'origine.
StackFrame(Int32)	Inizializza una nuova istanza della classe StackFrame che corrisponde a un frame sopra lo stack frame corrente.
StackFrame(Int32, Boolean)	Inizializza una nuova istanza della classe StackFrame che corrisponde a un frame sopra lo stack frame corrente, acquisendo facoltativamente informazioni sull'origine.
StackFrame(String, Int32)	Inizializza una nuova istanza della classe StackFrame che contiene solo il nome file e il numero di riga indicati.
StackFrame(String, Int32, Int32)	Inizializza una nuova istanza della classe StackFrame che contiene solo il nome file, il numero di riga e il numero di colonna indicati.

Campi

OFFSET_UNKNOWN

Definisce il valore restituito dal metodo GetNativeOffset() o dal metodo GetILOffset() quando l'offset nativo o MSIL (Microsoft Intermediate Language) è sconosciuto. Questo campo è costante.

Metodi

Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetFileColumnNumber()	Ottiene il numero della colonna nel file che contiene il codice in esecuzione. Le informazioni vengono generalmente estratte dai simboli di debug relativi al file eseguibile.
GetFileLineNumber()	Ottiene il numero della riga nel file che contiene il codice in esecuzione. Le informazioni vengono generalmente estratte dai simboli di debug relativi al file eseguibile.
GetFileName()	Ottiene il nome del file che contiene il codice in esecuzione. Le informazioni vengono generalmente estratte dai simboli di debug relativi al file eseguibile.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetILOffset()	Ottiene l'offset dall'inizio del codice MSIL (Microsoft Intermediate Language) per il metodo in esecuzione. Tale offset può essere approssimativo, in base al fatto che il compilatore JIT stia generando o meno un codice di debug. La generazione di queste informazioni di debug è controllata dall'elemento DebuggableAttribute.
GetMethod()	Ottiene il metodo in cui è in esecuzione il frame.
GetNativeOffset()	Ottiene l'offset dall'inizio del codice nativo compilato in modalità JIT (>Just-in-Time) per il metodo che è in esecuzione. La generazione di queste informazioni di debug è controllata dalla classe DebuggableAttribute.
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
ToString()	Compila una rappresentazione leggibile dell'analisi dello stack.

Metodi di estensione

GetNativeImageBase(StackFrame)	Restituisce un puntatore all'indirizzo di base dell'immagine nativa in esecuzione in questo stack frame.
GetNativeIP(StackFrame)	Ottiene un puntatore di interfaccia per l'inizio del codice nativo per il metodo in esecuzione.
HasILOffset(StackFrame)	Indica se è disponibile un offset dall'inizio del codice IL per il metodo in esecuzione.
HasMethod(StackFrame)	Indica se sono disponibili informazioni sul metodo in cui è in esecuzione il frame specificato.
HasNativeImage(StackFrame)	Indica se l'immagine nativa è disponibile per lo stack frame specificato.
HasSource(StackFrame)	Indica se il file che contiene il codice che è in esecuzione nello stack frame specificato è disponibile.

Si applica a

Vedi anche

• StackTrace