StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
text
Body
copied!<p>If I'm not mistaken, what you're looking to do (wishing you could do) is something like:</p> <pre><code>class ProductController<T> : Controller where T : ProductController { ILogger<T> _logger; ... etc } </code></pre> <p>I think that you can get a fairly flexible interface if you pull back a little from your design. You have three parts here -- a controller, a logger, and the object of the controller and logger, which I'll call a data transfer object. So, you have "controller of product" and "logger of product" (which you're currently calling "logger of controller of product").</p> <p>Let's say that you have this DTO object structure:</p> <pre><code>public class DataTransferBase { /*This is what both logger and controller operate on*/ } public class Product : DataTransferBase { } </code></pre> <p>Now, instead of the logger concerning itself with controllers, why not have the logger and controller both concern themselves with DTOs? So logger is like:</p> <pre><code>public interface ILogger { void Log(string message); } public interface ILogger<T> : ILogger where T : DataTransferBase { void Log(T item); } public class FileLogger<T> : ILogger<T> where T : DataTransferBase { public virtual void Log(T item) { /* Write item.ToString() to a file or something */ } public void Log(string message) { /* Write the string to a file */ } } </code></pre> <p>... and controller is like:</p> <pre><code>public interface IController<T> where T : DataTransferBase {} public class Controller<T> : IController<T> where T : DataTransferBase { /// <summary>Initializes a new instance of the ProductController class.</summary> public Controller(ILogger<T> logger) { } public virtual List<T> GetItems() { return new List<T>(); } } </code></pre> <p>What you have here now is a logger that will operate on any DTO and a controller that will operate on any DTO, and that controller happens to take as a constructor parameter, a logger that will operate on the same DTO that it does. Now, you can have more specific implementations if you want:</p> <pre><code>public class ProductFileLogger : FileLogger<Product> { public override void Log(Product item) { /* Get all specific with item */} } </code></pre> <p>and</p> <pre><code>public class ProductController : Controller<Product> { /// <summary> /// Initializes a new instance of the ProductController class. /// </summary> public ProductController(ILogger<Product> productLogger) : base(productLogger) { } public override List<Product> GetItems() { return new List<Product>(); } } </code></pre> <p>And, you can wire these up as specifically or generally as you please:</p> <pre><code>public class Client { private void DoSomething() { IController<Product> myController = new ProductController(new ProductFileLogger()); //If you want to be specific IController<Product> myController2 = new Controller<Product>(new ProductFileLogger()); //If you want a generic controller and specific logger IController<Product> myController3 = new Controller<Product>(new FileLogger<Product>()); //If you want to be as generic as possible } } </code></pre> <p>Please note, that I just kind of whipped this up on the fly, so it may not be optimal, but I'm just trying to convey the general idea. You can't declare a class with a generic type of itself (as far as I know), but you can have two classes interact (controller and logger) that operate on the same generic type. That is, IController can own an ILogger and when you instantiate IController, you force its logger to operate on the same type.</p>

Querying!

Guidance

An individual column

Larger individual text columns get their own page to allow for proper reading.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload