MethodBase.IsVirtual Propriedade

Definição

Namespace:

System.Reflection

Assemblies:

netstandard.dll, System.Runtime.dll

Origem:

MethodBase.cs

Obtém um valor que indica se o método é virtual.

public:
 property bool IsVirtual { bool get(); };

public bool IsVirtual { get; }

member this.IsVirtual : bool

Public ReadOnly Property IsVirtual As Boolean

Valor da propriedade

Boolean

true se esse método for virtual; caso contrário, false.

Exemplos

O exemplo a seguir é false exibido para IsFinal, o que pode levar você a pensar que MyMethod é substituível. O código é impresso false mesmo que MyMethod não esteja marcado virtual e, portanto, não pode ser substituído.

using System;
using System.Reflection;

public class MyClass
{
    public void MyMethod()
    {
    }
    public static void Main()
    {
        MethodBase m = typeof(MyClass).GetMethod("MyMethod");
        Console.WriteLine("The IsFinal property value of MyMethod is {0}.", m.IsFinal);
        Console.WriteLine("The IsVirtual property value of MyMethod is {0}.", m.IsVirtual);
    }
}

Imports System.Reflection

Public Class MyClass1
    
    Public Sub MyMethod()
    End Sub
    
    Public Shared Sub Main()
        Dim m As MethodBase = GetType(MyClass1).GetMethod("MyMethod")
        Console.WriteLine("The IsFinal property value of MyMethod is {0}.", m.IsFinal)
        Console.WriteLine("The IsVirtual property value of MyMethod is {0}.", m.IsVirtual)
    End Sub
End Class

Comentários

Um membro virtual pode referenciar dados de instância em uma classe e deve ser referenciado por meio de uma instância da classe .

Para determinar se um método é substituível, não é suficiente marcar que IsVirtual é true. Para que um método seja substituível, IsVirtual deve ser true e IsFinal deve ser false. Por exemplo, um método pode não ser virtual, mas implementa um método de interface. O Common Language Runtime requer que todos os métodos que implementam membros da interface devem ser marcados como virtual; portanto, o compilador marca o método virtual final. Portanto, há casos em que um método é marcado como virtual , mas ainda não é substituível.

Para estabelecer com certeza se um método é substituível, use um código como este:

if (MethodInfo.IsVirtual && !MethodInfo.IsFinal)

If MethodInfo.IsVirtual AndAlso Not MethodInfo.IsFinal Then

Se IsVirtual for false ou IsFinal for true, o método não poderá ser substituído.

Você pode determinar se o método atual substitui um método em uma classe base chamando o MethodInfo.GetBaseDefinition método . O exemplo a seguir implementa um IsOverride método que faz isso.

using System;
using System.Reflection;

public class ReflectionUtilities
{   
   public static bool IsOverride(MethodInfo method)
   {
      return ! method.Equals(method.GetBaseDefinition());
   }
}

public class Example
{
   public static void Main()
   {
      MethodInfo equals = typeof(Int32).GetMethod("Equals", 
                                        new Type[] { typeof(Object) } );
      Console.WriteLine("{0}.{1} is inherited: {2}", 
                        equals.ReflectedType.Name, equals.Name,
                        ReflectionUtilities.IsOverride(equals));
      
      equals = typeof(Object).GetMethod("Equals", 
                                        new Type[] { typeof(Object) } );
      Console.WriteLine("{0}.{1} is inherited: {2}", 
                        equals.ReflectedType.Name, equals.Name,
                        ReflectionUtilities.IsOverride(equals));
   }
}
// The example displays the following output:
//       Int32.Equals is inherited: True
//       Object.Equals is inherited: False

Imports System.Reflection

Public Class ReflectionUtilities
   Public Shared Function IsOverride(method As MethodInfo) As Boolean
      Return Not method.Equals(method.GetBaseDefinition())
   End Function
End Class

Module Example
   Public Sub Main()
      Dim equals As MethodInfo = GetType(Int32).GetMethod("Equals", 
                                         { GetType(Object) } )
      Console.WriteLine("{0}.{1} is inherited: {2}", 
                        equals.ReflectedType.Name, equals.Name,
                        ReflectionUtilities.IsOverride(equals))
      
      equals = GetType(Object).GetMethod("Equals", { GetType(Object) } )
      Console.WriteLine("{0}.{1} is inherited: {2}", 
                        equals.ReflectedType.Name, equals.Name,
                        ReflectionUtilities.IsOverride(equals))
   End Sub
End Module
' The example displays the following output:
'       Int32.Equals is inherited: True
'       Object.Equals is inherited: False