C#

Kevin Marois wrote:

it should be clear that it is indeed an optional parameter

void MyMethod(MyEnum me) {}

void MyMethod(int i) {}

enum xx
    {
    v1, v2
    }
void MyMethod(object o)
    {
    Console.WriteLine(o);
    if (o is xx) Console.WriteLine("XX");
    if (o is int) Console.WriteLine("INT");
    }
void TryIt()
    {
    int i = 13;
    xx x = xx.v2;
    MyMethod(i);
    MyMethod(x);
    MyMethod((int)x);
    }

13
INT
v2
XX
1
INT

void MyMethod(bool var1, MyEnum theEnum)
{
}

MyMethod(true);

MyMethod(true, MyEnum.TheValue);

enum MyEnum
    {
    DefaultValue,
    v1, v2
    }
void TryIt()
    {
    MyMethod(true, MyEnum.v1);
    MyMethod(false);
    }

void MyMethod(bool var1, MyEnum theEnum = MyEnum.DefaultValue) { Console.WriteLine(theEnum); }

void MyMethod(bool var1, params MyEnum[] theEnum) { Console.WriteLine(theEnum); }

enum MyEnum
    {
    DefaultValue,
    v1, v2
    }
void TryIt()
    {
    MyMethod(MyEnum.v1);
    MyMethod();
    }

void MyMethod(params MyEnum[] theEnum)
    {
    if (theEnum.Length == 1)
        {
        Console.WriteLine(theEnum[0]);
        }
    else if (theEnum.Length > 1)
        {
        throw new ArgumentException("Too many parameters");
        }
    }

void MyMethod() { }
void MyMethod(MyEnum theEnum) { }

void SomeMethod(SomeEnum? theEnum)
{
    if (theEnum.HasValue)
    {
        // The enum was passed:
        switch (theEnum.Value)
        {
            case SomeEnum.Item1:
            {
                ...
            }
        }
    }
    else
    {
        // The enum was not passed.
    }
}

// Pass the enum:
SomeMethod(SomeEnum.Item1);

// Don't pass the enum:
SomeMethod(null);

A procedure cannot detect at run time whether a given argument has been omitted or the calling code has explicitly supplied the default value

public void Method()
{
    Method(true, 0);
}
public void Method(YourEnum yourEnum)
{
    Method(false, yourEnum);
}
private void Method(bool ignoreEnum, YourEnum yourEnum)
{
    if(ignoreEnum)
    {
    }
    else
    {
    }
}

// This is an expensive call; cache the result:
Type myType = this.GetType(); 

// No need to examine sub-classes; if a property isn't
// defined on this class, you won't be able to copy it:
List<PropertyInfo> propertiesToCopy = GetFields(myType);

foreach (PropertyInfo property in resp.GetType().GetProperties())
{
    // IsSubclassOf returns false if the types are the same:
    if (property.PropertyType.IsSubclassOf(myType) || property.PropertyType == myType)
    {
        // Get the instance of ClassB:
        var propertyValue = property.GetValue(resp, null);
        
        // Can't copy properties from a null instance:
        if (propertyValue == null) continue;
        
        foreach (PropertyInfo propertyToCopy in propertiesToCopy)
        {
            var value = propertyToCopy.GetValue(propertyValue, null);
            propertyToCopy.SetValue(this, value, null);
        }
    }
}