Is direct reference really necessary?

Question

Let's say that we have 3 projects in our visual studio solution. Project A, B and C.

Project A code:

public class A
{
  public void someMethodA()
  {
    B b = new B();
    b.someMethodB(new C());
  }
}

Project B code:

public class B
{
  public void someMethodB(C c)
  {
    c.foo();  // we do something with C, call C's method
  }
}

Project C code:

public class C
{
  public void foo()
  {
    return; // just for testing
  }
}

Project B has a reference to project C, as it needs it (class C is needed in someMethodB). Project A has a reference to project B as it creates new object B and calls B's method - someMethodB().

At this point our solution won't compile, because project A needs reference to project C - it calls b.someMethodB(new C()) which needs project C. Does project A really needs reference to project C? Can't it get it from project B which also references it. I know that each project generates its own dll file and in bin directory there are 3 files, but still it could get what it needs from project B.

Project C isn't B domain, but we could get reference to C throught B.

Answer 1

If A were just calling a method on B without having to pass in C, even if that method itself used C, you wouldn't need a direct reference. However, since A needs to construct a C, it needs a direct reference to C in order to have the required metadata available to do so - this metadata is contained in C, and isn't copied to B.

If all metadata were copied from all referenced libraries up the chain so you only ever needed a direct reference to the dll you're using, the sizes of dlls would balloon, even if that functionality was never used - it would need to be there "just in case".

Answer 2

Why not make a method in project B that returns a new C()? Then you can avoid using C in A.

Answer 3

Yes, A needs the direct reference because it needs to know what kind of C it is dealing with.
For example there might be a System.Whatever.C and a MyProject.C - now what constructor should it call at new C() if you don't specify it?

If you want to avoid the reference in A you could create the instance of C in someMethodB instead of passing it as a parameter.

Answer 4

If your C assembly implements a certain interface (e.g. IC), and assembly A references the assembly where the interface is defined, then A won't have to know anything about C, as long as B method's return type is not concrete C, but instead the interface IC.

Schematically, it should be something like this:

This is most likely how you should organize your application anyway. I've noticed that you mentioned passing around a certain ConnectionInfo which contains information needed for the database connection, but you certainly don't want to have access to database credentials from your UI layer, or even be able to create actual DbConnection instances.

For example, you might implement a sort of a repository pattern, or a simple ORM like this:

// IC assembly (common assembly containing entities and repo interfaces)
public interface ISession : IDisposable
{
     // It can even be an empty, marker interface for the
     // outside world. Only `C` will know its internals anyway.
}

public interface IRepoFactory
{
     ISession OpenSession();
     IRepo<T> GetRepo<T>(ISession session);
}

Your B assembly can return a concrete Session instance to A:

// B assembly
// RepoFactory should also be internal to B assembly,
// the only thing that A needs is a method which will
// provide the implementation of IRepoFactory
internal RepoFactory : IRepoFactory
{
    public ISession OpenSession()
    {
        // this creates a concrete instance,
        // but callers will only get the `ISession` interface
        return C.CreateActualSession();
    }

    // other methods should also accept the session
    // object through its interface
    public IRepo<T> GetRepo<T>(ISession session)
    {
        return C.GetRepo(session);
    }
}

But your A assembly can use ISession without any idea how it's implemented under the hood:

// somewhere in `A` assembly
var repoFactory = B.GetRepoFactory();
using (var session = repoFactory.OpenSession())
{
    var ordersRepo = repoFactory.GetRepo<IOrdersRepo>(session);
    ordersRepo.Save(something);
}