Refactorizing overloads with the same scope but different calls [closed]

Question

Well I have 3 methods that are overloads, but in it's scope has the same scope except one method call.

    public static Texture2D DrawAnnulus(this Texture2D texture, Func<int, int, Color?> predicate, AnnulusConfig annulusConfig)
    {
        InitTexture(ref texture, annulusConfig.offset.x + annulusConfig.radius * 2, annulusConfig.offset.y + annulusConfig.radius * 2);

        Polar(texture, annulusConfig.offset.x, annulusConfig.offset.y, annulusConfig.radius, predicate);

        if (annulusConfig.apply)
            texture.Apply();

        return texture;
    }

    public static Texture2D DrawAnnulus(this Texture2D texture, SectorList list, AnnulusConfig annulusConfig)
    {
        InitTexture(ref texture, annulusConfig.offset.x + annulusConfig.radius * 2, annulusConfig.offset.y + annulusConfig.radius * 2);

        Polar(texture, annulusConfig.offset.x, annulusConfig.offset.y, annulusConfig.radius, (xx, yy) => Annulus(annulusConfig.offset.x, annulusConfig.offset.y, xx, yy, annulusConfig.radius2, list));

        if (annulusConfig.apply)
            texture.Apply();

        return texture;
    }

    public static Texture2D DrawAnnulus(this Texture2D texture, Color? color, AnnulusConfig annulusConfig)
    {
        InitTexture(ref texture, annulusConfig.offset.x + annulusConfig.radius * 2, annulusConfig.offset.y + annulusConfig.radius * 2);

        Polar(texture, annulusConfig.offset.x, annulusConfig.offset.y, annulusConfig.radius, (xx, yy) => Annulus(annulusConfig.offset.x, annulusConfig.offset.y, xx, yy, annulusConfig.radius2, color));

        if (annulusConfig.apply)
            texture.Apply();

        return texture;
    }

As you can see the only changing part is the Polar method call. The other part is only checks.

How could I simplify this?

Answer 1

You could create a single private method and pass the Polar call as an action from each of the overloads

public static Texture2D DrawAnnulus(this Texture2D texture, Func<int, int, Color?> predicate, AnnulusConfig annulusConfig)
    => DrawAnnulus(
        texture,
        annulusConfig,
        () => Polar(
            texture,
            annulusConfig.offset.x,
            annulusConfig.offset.y,
            annulusConfig.radius,
            predicate));

public static Texture2D DrawAnnulus(this Texture2D texture, SectorList list, AnnulusConfig annulusConfig)
    => DrawAnnulus(
        texture,
        annulusConfig,
        () => Polar(
            texture,
            annulusConfig.offset.x,
            annulusConfig.offset.y,
            annulusConfig.radius,
            (xx, yy) => Annulus(
                annulusConfig.offset.x,
                annulusConfig.offset.y,
                xx,
                yy,
                annulusConfig.radius2, list)));

public static Texture2D DrawAnnulus(this Texture2D texture, Color? color, AnnulusConfig annulusConfig)
    => DrawAnnulus(
        texture,
        annulusConfig,
        () => Polar(
            texture,
            annulusConfig.offset.x,
            annulusConfig.offset.y,
            annulusConfig.radius,
            (xx, yy) => Annulus(
                annulusConfig.offset.x,
                annulusConfig.offset.y,
                xx,
                yy,
                annulusConfig.radius2,
                color)));

private static Texture2D DrawAnnulus(Texture2D texture, AnnulusConfig annulusConfig, Action polarAction)
{
    InitTexture(ref texture, annulusConfig.offset.x + annulusConfig.radius * 2, annulusConfig.offset.y + annulusConfig.radius * 2);

    polarAction();

    if (annulusConfig.apply)
        texture.Apply();

    return texture;
}

Answer 2

You could create a single private method and decide there what overload to call based on the presence of the arguments

public static Texture2D DrawAnnulus(this Texture2D texture, 
            Func<int, int, Color?> predicate, 
            AnnulusConfig annulusConfig)
    => texture.DoDrawAnnulus(predicate, anulusConfig, null, null);

    public static Texture2D DrawAnnulus(this Texture2D texture
            ,SectorList list
            ,AnnulusConfig annulusConfig)
    => texture.DoDrawAnnulus(null, anulusConfig, list, null);    

    public static Texture2D DrawAnnulus(this Texture2D texture, 
            Color? color, 
            AnnulusConfig annulusConfig)
    => texture.DoDrawAnnulus(null, anulusConfig, null, color);

private static Texture2D DoDrawAnnulus(this Texture2D texture, 
                Func<int, int, Color?> predicate, 
                AnnulusConfig annulusConfig, 
                SectorList list, 
                Color? color)
    {
        InitTexture(ref texture, annulusConfig.offset.x + annulusConfig.radius * 2, annulusConfig.offset.y + annulusConfig.radius * 2);

        if (list != null)
        {
          Polar(texture, annulusConfig.offset.x, annulusConfig.offset.y, annulusConfig.radius, (xx, yy) => Annulus(annulusConfig.offset.x, annulusConfig.offset.y, xx, yy, annulusConfig.radius2, list));
        }
        else if (predicate != null)
        {
           Polar(texture, annulusConfig.offset.x, annulusConfig.offset.y, annulusConfig.radius, predicate);
        }
        else
        {
            Polar(texture, annulusConfig.offset.x, annulusConfig.offset.y, annulusConfig.radius, (xx, yy) => Annulus(annulusConfig.offset.x, annulusConfig.offset.y, xx, yy, annulusConfig.radius2, color));
        }

        if (annulusConfig.apply)
            texture.Apply();

        return texture;
    }

Answer 3

You could create helper methods for the repeated parts of the three overloads.

private static void InitTexture(ref Texture2D texture, AnnulusConfig annulusConfig)
    => InitTexture(ref texture, annulusConfig.offset.x + annulusConfig.radius * 2, annulusConfig.offset.y + annulusConfig.radius * 2);

private static void ApplyIfNecessary(Texture2D texture, AnnulusConfig annulusConfig)
{
    if (annulusConfig.apply)
        texture.Apply();
}