Why should I "connect" Injection Dependency in ASP.NET MVC?

Question

I thought the whole reason for interfaces, polymorphism, and the pattern, such as Inversion of Control via Injection Dependency Injection, was to avoid tight coupling, separation, modularity, etc.

Why do I need to explicitly "connect" the interface to a specific class, as in ASP.NET? Will my registry have any connection? How,

services.AddTransient<ILogger, DatabaseLogger>();

What if I take logger, ILogger and create a class of files and databases that implement this interface.

In my IoC,

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    public interface ILogger
    {
        void logThis(string message);

    }
    public class DatabaseLogger : ILogger
    {
        public void logThis(string message)
        {
            //INSERT INTO table.....
            System.Console.WriteLine("inserted into a databse table");
        }

    }
    public class FileLogger : ILogger
    {
        public void logThis(string message)
        {
            System.Console.WriteLine("logged via file");
        }

    }
    public class DemoClass
    {
        public ILogger myLogger;


        public DemoClass(ILogger myLogger)
        {
            this.myLogger = myLogger;
        }
        public void logThis(string message)
        {
            this.myLogger.logThis(message);
        }

    }
    class Program
    {

        static void Main(string[] args)
        {
            DemoClass myDemo = new DemoClass(new DatabaseLogger());  //Isn't this Dependency Injection?
            myDemo.logThis("this is a message");
            Console.ReadLine();

        }
    }
}

So, why should I register or "connect" to something? Isn't that dependency dependency through the constructor (I have a fundamental misunderstanding)? I could place any registrar that implemented ILogger there.

?

services.AddTransient<ILogger, DatabaseLogger>();
services.AddTransient<ILogger, FileLogger>();

Answer 1

- , , . , - .

, DemoClass 10 , , . , :

DemoClass myDemo = new DemoClass(new DatabaseLogger(new DbLoggerDependency1(), new DbLoggerDependency2(), new DbLoggerDependency3(), new DbLoggerDependency4()), new OtherDemoClassDependency(new OtherDependencyDependency1(), new OtherDependencyDependency2()));

, DemoClass. ? .

, , , .

, :

services.AddTransient<ILogger, DatabaseLogger>();
services.AddTransient<IDbLoggerDependency1, DbLoggerDependency1>();
services.AddTransient<IDbLoggerDependency2, DbLoggerDependency2>();
services.AddTransient<IDbLoggerDependency3, DbLoggerDependency3>();
services.AddTransient<IDbLoggerDependency4, DbLoggerDependency4>();
services.AddTransient<IOtherDemoClassDependency, OtherDemoClassDependency>();
services.AddTransient<IOtherDependencyDependency1, OtherDependencyDependency1>();
services.AddTransient<IOtherDependencyDependency2, OtherDependencyDependency2>();
services.AddTransient<IDemoClass, DemoClass>();

, DemoClass, IoC , :

class Foo
{
    private readonly IDemoClass _myDemo;

    public Foo(IDemoClass myDemo)
    {
        // myDemo is instantiated with the required dependencies based on your config
        _myDemo = myDemo;
    }

    public SomeMethod()
    {
        _myDemo.logThis("this is a message");
    }
}

, AutoFac, , .

Answer 2

. factory.

, . Factory .

, , , :

// Interface:
public interface ILogger : IDisposable
{
     void Log<TEntity>(TEntity entity);
}

// Concrete Implementation:
public class DatabaseLogger : ILogger
{
     public void Log<TEntity>(TEntity entity)
     {
          throw new NotImplementedException();
     }
}

public class TextLogger : ILogger
{
     public void Log<TEntity>(TEntity entity)
     {
          throw new NotImplementedException();
     }
}

IEnumerable<ILogger>, . , , :

public interface ILoggerFactory
{
     ILogger CreateDbLogger();

     ILogger CreateLogger();
}

public class LoggerFactory : ILoggerFactory
{
     public ILogger CreateDbLogger() => new DatabaseLogger();   

     public ILogger CreateLogger() =>   new TextLogger();
}

, Factory , services.AddTransient<ILoggerFactory, LoggerFactory>();. factory, :

public class Example
{
     public ILoggerFactory Factory { get; }
     public Example(ILoggerFactory factory)
     {
          Factory = factory;
     }


     // Utilize in a method.
     using(var logger = Factory.CreateDbLogger())
          logger.Log(...);

     // Utilize in a method.
     using(var logger = Factory.CreateLogger())
          logger.Log(...);
}

. , , Injection Dependency, . , "Factory Pattern" "Factory Method".