StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
text
Body
copied!<p>So this is a fairly common problem with generics. </p> <p>imagine 2 classes <code>class Base</code> and <code>class A</code>. <code>class A</code> descends from <code>Base</code>.</p> <pre><code> public class Base { } public class A : Base { } </code></pre> <p>Now consider <code>List<T></code>. You can make classes from <code>List<T></code> to hold Base or A:</p> <pre><code>List<Base> x = new List<Base>(); </code></pre> <p>and </p> <pre><code>List<A> y = new List<A>(); </code></pre> <p>It is a common misconception that the class of y must be a descendant of the class of x, but this cannot be true because x has a methods like <code>Add(Base item)</code> and y has a methods like <code>Add(A item)</code> and it is not possible for the compiler to guarantee that on y the interface will be compatible with the interface of x. this is because if you treat an instance of <code>List<A></code> as an instance of <code>List<Base></code> there is nothing to stop Add being called with an instance of Base or another subclass of Base. </p> <p>Now there are some parts of the interface that can be guarantee as compatible. They are any parts that return an instance of class A, since A can always take the place of Base. </p> <p>If your interface only output the generic and you are using .net 4 there is an easy solution. The out generic modifier:</p> <pre><code> public class Example { private readonly Dictionary<Type, IRepository<Base>> _repositoriesCollection = new Dictionary<Type, IRepository<Base>>(); public void DoSomething() { _repositoriesCollection.Add(typeof(A), new Repository<A>()); } } interface IRepository<out T> where T : Base { T MakeSomeItem(string info); //void AddSomeItem(string info, T itemToAdd); <- this will not // work because T // is out - so can't // go in... IEnumerable<T> MakeSomeListOfItems(); // This is OK because // IEnumerable<T> is declared as IEnumerable<out T> in the fx //List<T> Something(); <- not ok because List<T> is not List<out T> } public class Repository<T> : IRepository<T> where T : Base { public T MakeSomeItem(string info) { throw new NotImplementedException(); } public IEnumerable<T> MakeSomeListOfItems() { throw new NotImplementedException(); } } public class Base { } public class A : Base { } </code></pre> <p>This solution will not work for 2 cases; when you need to pass an item into you interface and when you are not using .net 4. </p> <p>There are numerous different solutions for both of those case also.</p> <p>1) I need to pass an item into the interface too and I am using .net 4 - just pass it as Base, if you need to maintain type safety wrap it with a generic method somewhere else. </p> <pre><code> interface IRepository<out T> where T : Base { T MakeSomeItem(string info); void AddSomeItem(string info, Base itemToAdd); } public class Repository<T> : IRepository<T> where T : Base { public T MakeSomeItem(string info){ throw new NotImplementedException(); } public void AddSomeItem(string info, Base itemToAdd) { T castedItem = (T) itemToAdd; //fails here at //run time if not // correct type AddSomeItem(info, itemToAdd); } public void AddSomeItem(string info, T itemToAdd) { /// do it for real... } } </code></pre> <p>2) If you are not working with .net 4 then there are other things that you can do too, force the repository to implement the Base version of your interface: </p> <pre><code>interface IRepository<T> where T : Base { T MakeSomeItem(string info); void AddSomeItem(string info, T itemToAdd) } public class Repository<T> : IRepository<Base>, IRepository<T> where T : Base { public T MakeSomeItem(string info) { throw new NotImplementedException(); } public void AddSomeItem(string info, Base itemToAdd) { T castedItem = (T) itemToAdd; //fails here at //run time if not // correct type AddSomeItem(info, itemToAdd); } public void AddSomeItem(string info, T itemToAdd) { /// do it for real... } Base IRepository<Base>.MakeSomeItem(string info) { return MakeSomeItem(info); } } </code></pre> <p>There is still yet more that you can do if you want to keep your input strongly typed - but I think my answer is long enough for now.</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