We Keep Coding

'The type arguments cannot be inferred from the usage'

I am having some troubles with generics and inheritance. I have an abstract class called CriteriaBase whose job it is to determine if an entity T matches the criteria defined in any sub-classes. The sub-classes have to implement a method which returns a Func representing the criteria. The problem arises when I try to use generics for the Func. Hopefully some code will illustrate my problem.
public abstract class CriteriaBase<T, U>
where T : ICrossoverable
where U : IChromosome
{
protected abstract Func<U, bool> Criteria { get; }
//some code removed for brevity
private int GetNumberOfCriteriaMatches(T season)
{
//1. works
//Func<IChromosome, bool> predicate = c => c.Genes == null;
//return season.Chromosomes.Count(predicate);
//2. doesn't work - The type arguments for method 'int
//System.Linq.Enumerable.Count<TSource>(this IEnumerable<TSource>,
//Func<TSource, bool>)'
//cannot be inferred from the usage. Try specifying the type arguments
//explicitly.
return season.Chromosomes.Count(Criteria);
}
}
My intention is that the CriteriaBase class should be generic and completely reusable.
An example sub-class:
public class TopTeamsPlayingEachOtherCriteria : CriteriaBase<Season, MatchDay>
{
//some code removed for brevity
protected override Func<MatchDay, bool> Criteria
{
get { return matchDay =>
matchDay.Fixtures.Count(
fixture =>
fixture.HomeTeam.TableGrouping.Ordering == 1
&& fixture.AwayTeam.TableGrouping.Ordering == 1) > 1; }
}
}
The problem is in the GetNumberOfCriteriaMatches() method. Option 2 is how I originally wrote the code but I get the compile error as listed. If I use option 1 then the code compiles but it means that when I override Criteria in the sub-class, I have to use IChromosome instead of MatchDay which doesn't work (I need to access specific features of a MatchDay). In my simple mind, options 1 and 2 are equivalent. Option 2 simply replaces IChromosome with a generic type U which is restricted to a class that implements IChromosome.
Is what I'm trying to achieve possible? If so, what am I missing/misunderstanding? If not, how should I approach this problem?
For completeness (included at the end as I'm not sure how much it helps with the question), here are the two entities that I'm currently using for T (Season) and U (MatchDay).
public class Season : ICrossoverable
{
private readonly IEnumerable<MatchDay> _matchDays;
public Season(IEnumerable<MatchDay> matchDays)
{
_matchDays = matchDays;
}
public IEnumerable<MatchDay> MatchDays
{
get { return _matchDays; }
}
//ICrossoverable implementation
public IEnumerable<IChromosome> Chromosomes
{
get { return _matchDays; }
}
}
public class MatchDay : IChromosome
{
private readonly int _week;
private readonly List<Fixture> _fixtures;
public MatchDay(int week, List<Fixture> fixtures)
{
_week = week;
_fixtures = fixtures;
}
//some code removed for brevity
public IEnumerable<Fixture> Fixtures
{
get { return _fixtures; }
}
//IChromosome implementation
public IEnumerable<IGene> Genes
{
get { return Fixtures; }
}
}

Well this is the problem:
public IEnumerable<IChromosome> Chromosomes
You're only declaring that you're returning a sequence of IChromosome values. Your criterion expects MatchDay values. You happen to know that it's actually returning a sequence of MatchDay values, but the compiler doesn't.
You could use Cast<> to check this at execution time:
return season.Chromosomes.Cast<U>().Count(Criteria);
... or you could change Chromosomes to return an IEnumerable<MatchDay>. Unfortunately we can't really tell whether that's a valid answer or not as we don't know how ICrossoverable is declared. Perhaps you should make ICrossoverable generic in the element type?

You should use keyword in before U in CriteriaBase definition. Something like this:
public abstract class CriteriaBase<T, in U>
where T : ICrossoverable
where U : IChromosome
Update. It will not work.
Try to specify type explicitly
private int GetNumberOfCriteriaMatches(T season)
{
....
return season.Chromosomes.Count<IChromosome>(Criteria);
}

C# generic class and EqualityComparer

Could anyone explain me what's wrong in the following class declaration:
private class PriorityQueueEntry<TPriorityValue,IIdentifiableEntry,IType> :
IComparer<PriorityQueueEntry<TPriorityValue,IIdentifiableEntry,IType>>
where TPriorityValue : IComparable
where IIdentifiableEntry : Identifier<IType>
{
public TPriorityValue Priority{get;private set;}
public IIdentifiableEntry Entry{get;private set;}
public PriorityQueueEntry(TPriorityValue val,IIdentifiableEntry entry)
{
Priority = val;
Entry = entry;
}
public int Compare(PriorityQueueEntry<TPriorityValue,IIdentifiableEntry,IType> first, PriorityQueueEntry<TPriorityValue,IIdentifiableEntry,IType> second)
{
if (first.Priority.CompareTo(second.Priority) < 0)
{
return -1;
}
else if (first.Priority.CompareTo(second.Priority) > 0)
{
return 1;
}
return EqualityComparer<IIdentifiableEntry>.Default.Equals( first.Entry.Id, second.Entry.Id);
}
}
The compiler complaing on the line where I use EqualityComparer. The error is the following:
error CS0176: Static member `object.Equals(object, object)' cannot be
accessed with an instance reference, qualify it with a type name
instead
I can't see where I'm using an instance reference.
Sorry, my fault. I posted an incomplete question.
Just for completeness, Idetifier class is just the following:
public interface Identifier<ID_TYPE>
{
ID_TYPE Id{get;set;}
}
using EqualityComparer there, was due to a copy and paste mistake(sorry guys, too much generic code today).
Of course my question was misposed, because I didn't give you all the elements you needed to answer (I'll remove it soon).
I needed IType to be IConvertible.
Thanks to all anyway.

This is an instance reference:
EqualityComparer<IIdentifiableEntry>.Default
The first problem is that you don't want to call object.Equals(object, object) at all. You really want to be calling the method on the equality comparer - but you're trying to call it with arguments which aren't convertible to IIdentifieableEntry.
The second problem is that you're trying to perform an ordering comparison, not an equality comparison, so you want Comparer<T>, not EqualityComparer<T>.
It's not clear what you're trying to achieve, but this code would at least compile:
return Comparer<IIdentifiableEntry>.Default.Compare(first.Entry, second.Entry);
If you really want to compare the Id properties, you need an equality comparer for the ID property type - and we don't know what that type is.
I suspect it's more likely that you really want something like this:
return Comparer<string>.Default.Compare(first.Entry.Id, second.Entry.Id);
... but it depends on the type of Id.

You have not shown the declaration of Identifier nor EqualityComparer. But I assume you need to change the line to something like:
return EqualityComparer<IIdentifiableEntry>.Default.Equals<IType>( first.Entry.Id, second.Entry.Id);
[EDIT]
As per Jon's comment. You do not want to equality comparer at all. Asumming that that Entry.Id is IComparable, then just:
return first.Entry.Id.CompareTo(second.Entry.Id);
I would recommend that Entry is restricted to IComparable, so we get something like:
class PriorityQueueEntry>
where TPriorityValue : IComparable
where TEntry : IComparable
{
public TPriorityValue Priority{get;private set;}
public TEntry Entry{get;private set;}
public PriorityQueueEntry(TPriorityValue val, TIdentifiableEntry entry)
{
Priority = val;
Entry = entry;
}
public int Compare(PriorityQueueEntry<TPriorityValue, TEntry first, PriorityQueueEntry<TPriorityValue, TEntry> second)
{
if (first.Priority.CompareTo(second.Priority) < 0)
{
return -1;
}
else if (first.Priority.CompareTo(second.Priority) > 0)
{
return 1;
}
return first.Enrtry.CompareTo(second.Entry);
}
}
You may want to add some null checks if TEntry is a class.

Finally I solved this way:
private class PriorityQueueEntry<TPriorityValue,IIdentifiableEntry,IType> :
IComparer<PriorityQueueEntry<TPriorityValue,IIdentifiableEntry,IType>>
where TPriorityValue : IComparable
where IIdentifiableEntry : Identifier<IType>
where IType : IConvertible
{
public TPriorityValue Priority{get;private set;}
public IIdentifiableEntry Entry{get;private set;}
public PriorityQueueEntry(TPriorityValue val,IIdentifiableEntry entry)
{
Priority = val;
Entry = entry;
}
public int Compare(PriorityQueueEntry<TPriorityValue,IIdentifiableEntry,IType> first, PriorityQueueEntry<TPriorityValue,IIdentifiableEntry,IType> second)
{
if (first.Priority.CompareTo(second.Priority) < 0)
{
return -1;
}
else if (first.Priority.CompareTo(second.Priority) > 0)
{
return 1;
}
return first.Entry.Id.ToUInt32(NumberFormatInfo.CurrentInfo) < first.Entry.Id.ToUInt32(NumberFormatInfo.CurrentInfo) ? -1:1;
}
}

Generic inheritance

I have a couple of questions about my understanding of an area of .NET.
Please consider the following mockup:
interface IListInterface<T>
{
//brevity
}
interface IClassInterface
{
int Count { get; }
}
class A<T> : IClassInterface
{
List<IListInterface<T>> MyList = new List<IListInterface<T>>();
public virtual int Count { get { return MyList.Count; } }
public void Add(IListInterface<T> item) { MyList.Add(item); }
public IEnumerable<String> GetAllAsString(T source) { return MyList.Select(o=>o.ToString()); }
}
class B<T1, T2> : A<T1>
{
List<IListInterface<T2>> MyList = new List<IListInterface<T2>>();
public override int Count { get { return base.Count + MyList.Count; } }
public void Add(IListInterface<T2> item) { MyList.Add(item); }
public IEnumerable<String> GetAllAsString(T1 source1, T2 source2)
{
return base.GetAllAsString(source1).Union(MyList.Select(o => o.ToString()));
}
}
class C<T1, T2, T3> : B<T1, T2>
{
List<IListInterface<T3>> MyList = new List<IListInterface<T3>>();
public override int Count { get { return base.Count + MyList.Count; } }
public void Add(IListInterface<T3> item) { MyList.Add(item); }
public IEnumerable<String> GetAllAsString(T1 source1, T2 source2, T3 source3)
{
return base.GetAllAsString(source1, source2).Union(MyList.Select(o => o.ToString()));
}
}
My questions are:
What is the term used to describe what Class B and Class C are doing? Generic type overload inheritance?
There tends to be a lot of repeated code when doing writing such an object, especially when adding more methods which end up just calling its base, and adding its own information to the return. Is there a better way to go about this to allow for a more maintainable class file?
Edited to address the necessity of this method
By using this type of inheritance, one could define a single object which would constrain the requirements for data input and explain its usage.
var x = new C<String, int, DateTime>();
You now know the types which make up the object and you will get a compile-time error if you attempt to call x.GetAllAsString(0, "hello", "world");
This type of object may not work for you, and its fitness for use is not the subject of my question. My questions are about the name of this method and about code reuse in this situation.

[For brevity; for the purposes of my answer, I'm going to focus only on the 'Add' method, as the question/solution applies to your entire model]
Unfortunately, I don't believe you can simplify what you have already implemented. In effect, what you are aiming to do is to constrain a type ('C') at runtime to a set of available types, which (if it worked!) would give you a limited subset of Add/GetAllAsString methods.
So, after going through the compiler, it sounds like you're hoping to turn a single class with a single method like;
public class Base<T>
{
Add(IListInterface<T> o);
}
into a runtime object that exposes an interface like;
public class C
{
Add(IListInterface<string> o) { ... }
Add(IListInterface<DateTime> o) { ... }
Add(IListInterface<int> o) { ... }
}
But, you can't really use generics in that way. The only way to really accomplish this is to approach it the way you have; with a stack of derived types which each add another constrained method to your type.

C# How do i access an element of a class when the type of class is Generic? [duplicate]

This question already has answers here:
Closed 11 years ago.
Possible Duplicate:
C# how do I compare two objects if they are of same type?
I have a generic function,
class Something {
public int found;
public Something() {
this.found = true;
}
}
List<Something> something;
public int countFound<T>(List<T> Organisms)
{
if (typeof(T) == typeof(Something))
{
foreach (T organism in Organisms)
{
// here i want to check something like organism.found == true how do i do it?
}
}
return 0;
}
Thanks in advance for all the help!

You probably want something like this:
class Organism
{
public bool Found
{
get;
set;
}
}
class Something : Organism
{
public Something()
{
this.Found = true;
}
}
public class Program
{
public int countFound<T>(List<T> Organisms)
where T : Organism
{
foreach (T organism in Organisms)
{
if (organism.Found)
{
// Do something with the organism
}
}
return 0;
}
}
The key points here are:
You have a common base class called Organism that defines the Found property
The Something class derives from Organism, setting Found to true when it gets constructed
The CountFound method has a generic constraint (the where clause) on T specifying that it must derive from Organism (The Something meets this criteria). This then allows you to use any method or property that Organism provides in the method - in this case Organism.Found.

There are two options here, depending on what you want the function to do:
If the countFound function must take all types T, but you want a special case when T is (or inherits from) Something, then you can use this:
public int countFound<T>(List<T> Organisms)
{
if (typeof(T) == typeof(Something) || typeof(T).IsSubclassOf(typeof(Something)))
{
foreach (T organism in Organisms)
{
Something s = (Something)(object)organism;
// do whatever you like with s
}
}
return 0;
}
If you only want the function to take type T when T is (or inherits from) Something, then that's simpler:
public int countFound<T>(List<T> Organisms) where T : Something
{
foreach (T organism in Organisms)
{
// here organism will have all of the properties of Something
}
return 0;
}

You must limit your generic to one (or more) interface which dictates to implement to properties which are needed by your generic!
Let's say interface IFound implements the property you want to check:
public int countFound<T>(List<T> Organisms) where T : IFound
{
if (typeof(T) == typeof(Something))
{
foreach (T organism in Organisms)
{
if(organism.found)) // done because IFound tells T has a property with this name
}
}
return 0;
}
IFound is an interface you must implement by yourself. For example:
interface IFound
{
bool Found { get; }
}
Your class Something must implement IFound:
class Something : IFound
{
public bool Found
{
get { return true; } // implement your condition in a method called here
}
}
Then you can call your method like you wanted:
int a = countFound<Something>(List<Something> parameter);

In your scenario it seems you wouldn't want to try to implement an equality function because equality would always be defined within the context of the types you are comparing(specific code per type to do the comparisons). This would work for you if all your T 's were of a common type(base class) and the equality condition could be expressed in terms of the base class' common properties etc...

Conversion of IEnumerable<T> for Extension Method Issue

I have the following class and extension class (for this example):
public class Person<T>
{
public T Value { get; set; }
}
public static class PersonExt
{
public static void Process<TResult>(this Person<IEnumerable<TResult>> p)
{
// Do something with .Any().
Console.WriteLine(p.Value.Any());
}
}
I was expecting I could write something like the following and it would work, but it doesn't:
var x = new Person<List<String>>();
x.Process();
Since List is lower in the inheritance tree than IEnumerable, shouldn't this be valid? It works if I new up a Person<IEnumerable<String>> of course because that's the direct type.
I'm trying to use an extension method that can be applied to all Person<T>'s as long as T implements IEnumerable<Something> because I need to use the .Any() method.
EDIT: Maybe my understanding of covariance is off? I know IEnumerable<String> should convert to IEnumerable<Object>, but couldn't IList<String> convert to IEnumerable<String>?
EDIT2: Forgot to mention that I am using .net 4.0.

I know IEnumerable<String> should
convert to IEnumerable<Object>, but
couldn't IList<String> convert to
IEnumerable<String>?
IList<String> can convert to IEnumerable<String>. The problem is that you're trying to convert Person<List<String>> to Person<IEnumerable<String>>, which is illegal. For example, it's perfectly valid to write:
var x = new Person<IEnumerable<String>>();
x.Value = new string[0];
since Value is of type IEnumerable<String> and a string array is an IEnumerable<String>. However, you cannot write:
var x = new Person<List<String>>();
x.Value = new string[0];
since Value is of type List<String>. Since you can't use a Person<List<String>> in all places where you could use a Person<IEnumerable<String>>, it's not a legal cast.
Note that you can do something similar to what you want if you add a second type parameter to your extension method:
public static void Process<TResult, TList>(this Person<TList> p)
where TList : IEnumerable<TResult>
{
Console.WriteLine(p.Value.Any());
}
Unfortunately, the compiler won't be able to infer both type parameters, so you would have to call it like this:
var x = new Person<List<String>>();
x.Process<String, List<String>>();
If you are using C# 4.0 and can use covariance, then you can define a covariant interface for person:
public interface IPerson<out T>
{
T Value { get; }
}
public class Person<T>
: IPerson<T>
{
public T Value { get; set; }
}
And then write your extension method as:
public static void Process<TResult>(this IPerson<IEnumerable<TResult>> p)
{
// Do something with .Any().
Console.WriteLine(p.Value.Any());
}
Since IPerson<T>.Value is read-only, a IPerson<List<String>> can be used everywhere that an IPerson<IEnumerable<String>> can be, and the conversion is valid.

I'm not sure you've quite grasped the correct use of generics. In any event ...
The only thing that is incorrect is your declaration of extension method, and the way you are attempting to constrain the extension method.
public static class ThingExtensions
{
public static void Process<T>(this Thing<T> p)
where T : IEnumerable<string>
{
// Do something with .Any().
Console.WriteLine(p.Value.Any());
}
}
All I've really done is rename Person to Thing so that we're not getting hung up on what a Person<List<string>> really is.
public class Thing<T>
{
public T Value { get; set; }
}
class ListOfString : List<string>
{ }
class Program
{
static void Main(string[] args)
{
var x = new Thing<ListOfString>();
x.Value = new ListOfString();
x.Process();
x.Value.Add("asd");
x.Process();
var x2 = new Thing<int>();
// Error 1 The type 'int' cannot be used as type parameter 'T'
// in the generic type or method
// 'ThingExtensions.Process<T>(Thing<T>)'.
// There is no boxing conversion from 'int' to
// 'System.Collections.Generic.IEnumerable<string>'.
//x2.Process();
Console.Read();
}
}
You could also move the generic constraint to the Thing<T> if that was more applicable.

You mention covariance, but don't actually use it. You have to specify in or out on your generic parameters. Note that co/contravariance doesn't work on class types; they must be applied to interfaces.
So, introducing an interface and making it covariant:
public interface IPerson<out T>
{
T Value { get; }
}
public class Person<T> : IPerson<T>
{
public T Value { get; set; }
}
public static class PersonExt
{
public static void Process<TResult>(this IPerson<IEnumerable<TResult>> p)
{
// Do something with .Any().
Console.WriteLine(p.Value.Any());
}
}
allows this code to compile:
var x = new Person<List<String>>();
x.Process();