Generic extension where clause

Question

I have two structs that are basically the same, both have two of the same public properties. I am trying to combine some extensions however when you define:
private static Dictionary<string, List<string>> ToDictionary<T>(this T source) where T : IEnumerable<StructA>, IEnumerable<StructB>
foreach (var item in source)
item.Name ...
Obviously source must now inherit from both IEnumerable interfaces, not one or the other. The problem is I am accessing the properties (such as .Name) and if I use a single interface, IEnumerable<object> the extension does not know if the properties exist.
Can this be done?
Thanks!

Answer 1

>>Obviously source must now inherit from both IEnumerable interfaces, not one or the other.
You cannot enforce the type argument to be of type IEnumerable<StructA>
OR IEnumerable<StructB>.
>>I have two structs that are basically the same
There is no "basically the same" in object-oriented programming. Either they are of the same type or they are not.
>>The problem is I am accessing the properties (such as .Name) and if I use a single interface, IEnumerable<object> the extension does not know if the properties exist.
If both structs have the same public property you could define an interface which declares this property and then make both structs implement the interface:
public interface HasName
string Name { get; set; }
public struct StructA : HasName
public string Name { get; set; }
public struct StructB : HasName
public string Name { get; set; }
You can then use the interface as the type constraint:
private static Dictionary<string, List<string>> ToDictionary<T>(this T source) where T : IEnumerable<HasName>
Note that an IEnumerable<StructA> cannot be implicitly converted to an IEnumerable<HasName> though so you still won't be able to call the extension method on a field declared as IEnumerable<StructA> rather than IEnumerable<HasName>.
Just because a StructA can be implicitly converted to a HasName it doesn't mean that a IEnumerable<StructA> can be converted to a IEnumerable<HasName>.
But you will be able to access the name property of any struct that implements the HasName interface, e.g:
List<HasName> sa = new List<HasName>();
sa.Add(new StructA());
sa.Add(new StructB());
var dict = sa.MyToDictionary(...);
If you want to treat a StructA differently to StructB in any way, it makes no sense to use a single generic method for both types. Then you should use a method per type instead.
Hope that helps.
Please remember to close your threads by marking helpful posts as answer and then start a new thread if you have a new question.