ASP.net service that sends email whenever an entity is updated
The very first problem is to move some responsibilities out of the controller. IMHO controllers should do as little as possible because their responsibility should be to glue the HTTP request to the domain model.

In your case the controller should not create and configure the service also because it makes impossible (OK...just hard) to test both in isolation. Please pick a better name but the very first thing to do is to receive an IEmailService service exactly the same way you receive the others. 

This MIGHT not be always possible without some major refactoring then I'd start introducing a factory:

public ProjectController(IProjectService service, IEmailServiceFactory factory) {
   _service = service;
   _emailService = factory.GetService();
}


That hypothetical factory method is simply:

public GetService() {
    var emailService = new EmailService(_service, emailRepos);
    var settings = Settings.Load(connection);
    emailService.SmtpServer = settings["SmtpServer"];

    // ...
    emailService.TemplateASubjectFormat = settings["TemplateASubjectFormat"];
    // ...

    return emailService;
} 


This is easy because you're just moving your code from one class to another and you introduced another service.

Now controllers came back to a reasonable level of responsibilities (and complexity) and they're also testable because you can mock the IEmailServiceFactory service (no need to send tons of e-mails when running your tests on the controller...)

As soon as you're ready (or simply as a second step on your refactoring) you should receive the IEmaiLService service directly - instead of going trough a factory.



There are also few things to say about the other code. Those initialization lines are tedious, if you're OK to tie your EmailService to its DB representation then you can decorate its properties:

[ConfigurationColumName("SmptServer")]
public string SmtpServer {get;set;}


You can then use a touch of Reflection to enumerate its properties:

foreach (var property in typeof(EMailService).GetProperties()) {
    var attribute = property.GetCustomAttribute&lt;ConfigurationColumNameAttribute&gt;();
    if (attribute == null) {
        continue;
    }

    property.SetValue(obj, settings[attribute.Name]);
}


Of course you need to define a ConfigurationColumNameAttribute class and add proper error handling.



We then arrive to the second error-prone (and not scalable) part of your code. You hard-coded the number of templates. What if you will ever need 3? Or 4? Or just one? You may simply use a dictionary (if not an array):

public Dictionary&lt;string, TemplateDefinition&gt; Templates { get; } = new ...;


Where TemplateDefinition has Subject and Content properties. Code should now be simple enough that you may even avoid Reflection.

SendEmailWithTemplateA() and SendEmailWithTemplateB() are almost exact duplicates, if you use a dictionary then there should not be any repeated code.



Mechanism you're using for templating is fragile. It's hard to write long strings using {0} and {1} as placeholders. Do yourself a BIG favor and switch to a small, fast and well-tested templating engine like Mustache. You'll be able to write your template as Hello {{username}}, we write to you to inform you about the new {{product}}.... It'll be much easier to configure and edit your templates and you'll minimize the chances to mix-up things when changing something in your code. Do not forget that this has to be tested too.



Do not catch Exception, is OutOfMemoryException or AccessViolationException something you want to handle that way?