Many-To-Many movie director system I have the following relationship in EF Core 3.1.1 (Many-To-Many):
public partial class Movie
{
    public Movie()
    {
        Directors = new HashSet&lt;MovieDirector&gt;();
    }

    public int Id { get; set; }
    public string Title { get; set; }

    public virtual ICollection&lt;MovieDirector&gt; Directors { get; set; }
}

public partial class Director
{
    public Director()
    {
        MovieDirector = new HashSet&lt;MovieDirector&gt;();
    }

    public string Id { get; set; }
    public string Name { get; set; }

    public virtual ICollection&lt;MovieDirector&gt; MovieDirector { get; set; }
}

public partial class MovieDirector
{
    public int Id { get; set; }
    public int MovieId { get; set; }
    public string DirectorId { get; set; }

    public virtual Movie Movie { get; set; }
    public virtual Director Director { get; set; }
}

And I have the following method to create a Director:
public Director CreateDirector(int movieId, Director director)
{
    var movie = _repository.Movie.FirstOrDefault(w =&gt; w.Id == movieId);

    movie.Directors.Add(new MovieDirector{ Director = director });

    _repository.SaveChanges();

    return director;
}

The CreateDirector method can perfectly create a new Director including relationships.
My biggest question is if every time I need to insert in a table that has a relationship I will need:

Find the parent/root entity (Movie)

Create a new MovieDirector object

Associate the new MovieDirector object with the parent/root, like:
movie.Directors.Add(new MovieDirector)



Is this correct or is there some kind of shortcut?
When two entities are related in many-to-many relationship, neither of them are a parent/root entity nor a dependent/child entity. They are two individual entities totally independent of each other. They are related, but neither of them depends on the other.
At database level a parent/child dependency is mapped through a foreign-key. For a many-to-many relationship there is no foreign-key involved, and the relationship is mapped through a joining table, which we model with a joining entity at code level, (the MovieDirector entity in your example).
So, if Director and Movie are in a many-to-many relationship, then Movie is by no means a parent entity of Director, or vice-versa. Therefore, you should always be able to create a Director entity independent of any information referencing any movie. And from that perspective I see a major flaw in your code - currently you cannot create a Director entity independently, you need a movieId for that (which you shouldn't).
Think about a possible scenario where you might need to select one or more directors while creating a new movie, and that might be the first time some of those directors gets linked with a movie. What I'm trying to imply is, you can always have a director, or want to create one, for whom there is no movie in the database.
The signature of your CreateDirector method should be like -
public Director CreateDirector(Director director)

First setup any related entities (if there is any) before reaching the CreateDirector method -
director.MovieDirectors.Add(new MovieDirector { MovieId = movieId });

and then call for creating the new director -
public Director CreateDirector(Director director)
{
    _repository.Directors.Add(director);
    _repository.SaveChanges();
    return director;
}

Now you can create a director independently or, along with its related entities. I hope that simplifies your current approach too.