C# Call function from another class

I see 2 ways to accomplish this, one easier but (arguably) less elegant, one a little more involved but (arguably) more elegant

1. The less elegant solution: Singleton

A Singleton pattern enforces that there can only ever be one instance of a class at any given time, this seems to line up with your description of A (which from here on out I'll call Foo, and I'll be calling B Bar). So let's implement it:

public class Foo
{
    private static Foo _instance;

    public static Foo Instance => _instance ?? (_instance = new Foo());

    // Private constructor so no one else can instantiate Foo
    private Foo() { }

    public void FunctionToBeCalled() { /* your code here */ }
}

public class Bar
{
    public void FunctionToBeCalledAfter()
    {
        // Your existing code here
        Foo.Instance.FunctionToBeCalled();
    }
}

Now, the problem here is if your requirements ever change and you need multiple Foos, that'll be quite a refactor to implement it. Another (larger) downside is that we explicitly reference (i.e depend on) Foo, which isn't great and a problem if Bar is inside a project/ library that cannot directly reference Foo. Luckily solution 2 fixes those problems:

2. The more elegant solution: Events

public class Foo
{
    // We don't need Foo to be a singleton anymore
    public void FunctionToBeCalled() { /* Your code here */ }
}

public class Bar
{
    public delegate void FunctionToBeCalledAfterEventHandler();

    public event FunctionToBecalledAfterEventHandler FunctionToBeCalledAfterEvent;

    public void FunctionToBeCalledAfter()
    {
        // Your existing code here
        OnFunctionToBeCalledAfterEvent(); // Fire the event
    }

    private void OnFunctionToBeCalledAfterEvent()
    {
        FunctionToBeCalledEvent?.Invoke();
    }
}

Now, everywhere where you're creating an instance of Bar you need to have a reference to Foo and subscribe to the event like so:

// foo = instance of class Foo
var bar = new Bar();

// The compiler is smart enough to find out that 'FunctionToBeCalledAfterEvent'
// has the same signature as 'FunctionToBeCalledAfterEvent' and can call it directly
// If this just so happens to not be case, see second way to subscribe to events
bar.FunctionToBeCalledAfterEvent += foo.FunctionToBeCalled;

// Or
bar.FunctionToBeCalledAfterEvent += () => foo.FunctionToBeCalled();

Events are great

Class B can have an event that other parties can handle. At the end of B.FunctionToBeCalledAfter this event would be invoked. Anyone who registered for this event would then be notified. Usual boilerplate code involves one virtual method that invokes one event. It's the standard way of adding events. If there is no need for additional data in the event then EventArgs is used. If additional data is needed then you could replace EventArgs with EventArgs<YourData>, or as an alternative, introduce a class XxxArgs derived from EventArgs with this additional data.

Class B
{
    public event EventHandler FinishedFunctionToBeCalledAfter;

    protected virtual void OnFinishedFunctionToBeCalledAfter(EventArgs e)
    {
        EventHandler handler = FinishedFunctionToBeCalledAfter;
        handler?.Invoke(this, e);
    }

    public void FunctionToBeCalledAfter()
    {
        ...

        OnFinishedFunctionToBeCalledAfter(EventArgs.Empty);
    }
}

Now when class A gets a hold of an object of class B it would add its event handler to it:

class A
{
    public void FunctionToBeCalled();

    public void FinishedFunctionToBeCalledAfter(object source, EventArgs e);

    public void IntroduceObject(B b)
    {
        b.FinishedFunctionToBeCalledAfter += FinishedFunctionToBeCalledAfter;
    }
}

When this object b of class B should end its life class A must know about it so that it can remove its event handler:

b.FinishedFunctionToBeCalledAfter -= FinishedFunctionToBeCalledAfter;