What is BindingFlags.Default equivalent to?

Question

I remember reading somewhere, when using reflection and the overload of GetMethod that accepts a bitmask of BindingFlags, that BindingFlags.Default is equivalent to BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance or something. Can anyone tell me what values are specifically included in BindingFlags.Default? The MSDN documentation doesn't say, and I can't find the answer anywhere.

Exultation

Answer 1

If you 'go to definition' on it, you'll see:

public enum BindingFlags
{
    // Summary:
    //     Specifies no binding flag.
    Default = 0,
    //
    // Summary:
    //     Specifies that the case of the member name should not be considered when
    //     binding.
    IgnoreCase = 1,
    //
    // Summary:
    //     Specifies that only members declared at the level of the supplied type's
    //     hierarchy should be considered. Inherited members are not considered.
    DeclaredOnly = 2,
    //
    // Summary:
    //     Specifies that instance members are to be included in the search.
    Instance = 4,
    //
    // Summary:
    //     Specifies that static members are to be included in the search.
    Static = 8,
    //
    // Summary:
    //     Specifies that public members are to be included in the search.
    Public = 16,
    //
    // Summary:
    //     Specifies that non-public members are to be included in the search.
    NonPublic = 32,
    //
    // Summary:
    //     Specifies that public and protected static members up the hierarchy should
    //     be returned. Private static members in inherited classes are not returned.
    //     Static members include fields, methods, events, and properties. Nested types
    //     are not returned.
    FlattenHierarchy = 64,
    //
    // Summary:
    //     Specifies that a method is to be invoked. This must not be a constructor
    //     or a type initializer.
    InvokeMethod = 256,
    //
    // Summary:
    //     Specifies that Reflection should create an instance of the specified type.
    //     Calls the constructor that matches the given arguments. The supplied member
    //     name is ignored. If the type of lookup is not specified, (Instance | Public)
    //     will apply. It is not possible to call a type initializer.
    CreateInstance = 512,
    //
    // Summary:
    //     Specifies that the value of the specified field should be returned.
    GetField = 1024,
    //
    // Summary:
    //     Specifies that the value of the specified field should be set.
    SetField = 2048,
    //
    // Summary:
    //     Specifies that the value of the specified property should be returned.
    GetProperty = 4096,
    //
    // Summary:
    //     Specifies that the value of the specified property should be set. For COM
    //     properties, specifying this binding flag is equivalent to specifying PutDispProperty
    //     and PutRefDispProperty.
    SetProperty = 8192,
    //
    // Summary:
    //     Specifies that the PROPPUT member on a COM object should be invoked. PROPPUT
    //     specifies a property-setting function that uses a value. Use PutDispProperty
    //     if a property has both PROPPUT and PROPPUTREF and you need to distinguish
    //     which one is called.
    PutDispProperty = 16384,
    //
    // Summary:
    //     Specifies that the PROPPUTREF member on a COM object should be invoked. PROPPUTREF
    //     specifies a property-setting function that uses a reference instead of a
    //     value. Use PutRefDispProperty if a property has both PROPPUT and PROPPUTREF
    //     and you need to distinguish which one is called.
    PutRefDispProperty = 32768,
    //
    // Summary:
    //     Specifies that types of the supplied arguments must exactly match the types
    //     of the corresponding formal parameters. Reflection throws an exception if
    //     the caller supplies a non-null Binder object, since that implies that the
    //     caller is supplying BindToXXX implementations that will pick the appropriate
    //     method.
    ExactBinding = 65536,
    //
    // Summary:
    //     Not implemented.
    SuppressChangeType = 131072,
    //
    // Summary:
    //     Returns the set of members whose parameter count matches the number of supplied
    //     arguments. This binding flag is used for methods with parameters that have
    //     default values and methods with variable arguments (varargs). This flag should
    //     only be used with System.Type.InvokeMember(System.String,System.Reflection.BindingFlags,System.Reflection.Binder,System.Object,System.Object[],System.Reflection.ParameterModifier[],System.Globalization.CultureInfo,System.String[]).
    OptionalParamBinding = 262144,
    //
    // Summary:
    //     Used in COM interop to specify that the return value of the member can be
    //     ignored.
    IgnoreReturn = 16777216,
}

So, it looks like BindingFlags.Default != BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance.

Eastnortheast

Derp, I didn't think of doing that. – Exultation

I went to the definition of the class and read that, how did you figure out what Default is equivalent to tho? – Naturalistic

Its value is 0, so it's not equivalent to any combination of the other options. – Eastnortheast

Answer 2

BindingFlags.Default specifies no binding flags. It is up to the user of the enumeration to choose what to do. System.Type.GetMethods() for example returns all public methods.

Foresail

in Type.GetProperties, it's equivalent to BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public (learn.microsoft.com/en-us/dotnet/api/…) – Warram