Extending objects that get returned as generics

  • Thread starter Thread starter Keith Elder
  • Start date Start date
K

Keith Elder

I ran into a unique situation today whereby I have a core library that
uses generics to return users from Active Directory. Example:

List<ADUser> users = ADUser.GetByName("First", "Last");

This works great. However, what I need to do is extend the ADUser
object like so:

class DataGridUser : ADUser
{
// add some new properties
// add some new methods for databinding
}

I can't figure out how to extend it though since the GetByName() returns
a List<ADUser>. Trying this doesn't work:

List<DataGridUser> users = DataGridUser.GetByName("First", "Last");

This throws an exception that GetByName cannot convert DataGridUser to
ADUser. What am I missing or doing wrong? Anyone got any ideas?

-Keith
 
Keith said:
I ran into a unique situation today whereby I have a core library that
uses generics to return users from Active Directory. Example:

List<ADUser> users = ADUser.GetByName("First", "Last");

This works great. However, what I need to do is extend the ADUser
object like so:

class DataGridUser : ADUser
{
// add some new properties
// add some new methods for databinding
}

I can't figure out how to extend it though since the GetByName() returns
a List<ADUser>. Trying this doesn't work:

List<DataGridUser> users = DataGridUser.GetByName("First", "Last");

This throws an exception that GetByName cannot convert DataGridUser to
ADUser. What am I missing or doing wrong? Anyone got any ideas?
Click to expand...

Are you sure the compiler doesn't complain that it can't convert
List<ADUser> to List<DataGridUser>? The problem is that List<ADUser>
and List<DataGridUser> are entirely different types, even though
DataGridUser derives from ADUser.

There's a recent thread on this newsgroup about it, called "Casting
generic collections & inheritance". Look on groups.google.com for it if
you don't have it locally.

If this isn't what you mean, please provide a short but complete
example which demonstrates your problem. See
http://www.pobox.com/~skeet/csharp/complete.html for more details on
what I mean by that.

Jon
 
"Keith Elder" <[email protected]> a écrit dans le message de
news: (e-mail address removed)...

| I can't figure out how to extend it though since the GetByName() returns
| a List<ADUser>. Trying this doesn't work:
|
| List<DataGridUser> users = DataGridUser.GetByName("First", "Last");
|
| This throws an exception that GetByName cannot convert DataGridUser to
| ADUser. What am I missing or doing wrong? Anyone got any ideas?

Correct. See Jon's reply. But assuming that you are creating DataGridUser
instances and adding them to a List<ADUser>, then you can always cast the
individual items to DataGridUser.

As Jon said, the two type of generic list are not related, they are sibling
classes. Your other choice is to modify the GetByName method or add another
method that returns the type of list that you are wanting.

Joanna
 
Joanna said:
"Keith Elder" <[email protected]> a écrit dans le message de
news: (e-mail address removed)...

| I can't figure out how to extend it though since the GetByName() returns
| a List<ADUser>. Trying this doesn't work:
|
| List<DataGridUser> users = DataGridUser.GetByName("First", "Last");
|
| This throws an exception that GetByName cannot convert DataGridUser to
| ADUser. What am I missing or doing wrong? Anyone got any ideas?

Correct. See Jon's reply. But assuming that you are creating DataGridUser
instances and adding them to a List<ADUser>, then you can always cast the
individual items to DataGridUser.

As Jon said, the two type of generic list are not related, they are sibling
classes. Your other choice is to modify the GetByName method or add another
method that returns the type of list that you are wanting.

Joanna
Click to expand...


Thanks Joanna,

I think my problem lies in the fact that I really cannot touch this core
library ADUser. Extending it is the only way to really modify it.
Think of it no differently than System.Data.XXXX. Pretty much all apps
rely on that object to work and it rarely gets modified.

I did try casting to DataGridUser, however it fails because the method
GetByName returns List<ADUser>. Care to give an example of what you
were thinking?
 
"Keith Elder" <[email protected]> a écrit dans le message de
news: (e-mail address removed)...

| I did try casting to DataGridUser, however it fails because the method
| GetByName returns List<ADUser>. Care to give an example of what you
| were thinking?

{
List<ADUser> users = DataGridUser.GetByName("First", "Last");

if (users.Count > 0)
DataGridUser user = (DataGridUser) users[0];
...
}

This assumes that the objects in the list really are DataGridUsers.

Joanna
 
This throws an exception that GetByName cannot convert DataGridUser to
ADUser. What am I missing or doing wrong? Anyone got any ideas?
Click to expand...

I have two things to say about this...

First, being one of the people involved in the thread that Jon referred to,
I would think that the problem here is that the person that wrote the
ADUser library didn't fully consider what users might want to do with those
objects and functions that the library provides. What I mean by this is
that there are probably functions provided by the library that you want to
use List<DataGridUser> with but can't because they expect List<ADUser>, for
example:

public void DoSomething(List<ADUser> list) { ... }

Based on the discussion thread with Jon, what the author should have done
is:

public void DoSomething<T>(List<T> list) where T : ADUser { ... }

It wouldn't surprise me at all if a lot of libraries that are written to
support generics aren't written this way, simply because they don't have to
be.

Jon, would you agree that *in general*, any functions which accept generics
should be written to support this least generic form of the function? It
almost seems as if the first form (with List<ADUser>) of the function
signature should be the "not recommended" way of writing this function,
because it totally limits the flexibility of the function as it relates to
classes derived from ADUser.

Second, Keith, if you can't make alterations to the base library, then you
might want to look at the "Decorator" pattern. I think it might help here.
Here's one:

http://www.dofactory.com/Patterns/PatternDecorator.aspx

-mdb
 
Michael said:
I have two things to say about this...

First, being one of the people involved in the thread that Jon referred to,
I would think that the problem here is that the person that wrote the
ADUser library didn't fully consider what users might want to do with those
objects and functions that the library provides. What I mean by this is
that there are probably functions provided by the library that you want to
use List<DataGridUser> with but can't because they expect List<ADUser>, for
example:

public void DoSomething(List<ADUser> list) { ... }

Based on the discussion thread with Jon, what the author should have done
is:

public void DoSomething<T>(List<T> list) where T : ADUser { ... }

It wouldn't surprise me at all if a lot of libraries that are written to
support generics aren't written this way, simply because they don't have to
be.

Jon, would you agree that *in general*, any functions which accept generics
should be written to support this least generic form of the function? It
almost seems as if the first form (with List<ADUser>) of the function
signature should be the "not recommended" way of writing this function,
because it totally limits the flexibility of the function as it relates to
classes derived from ADUser.

Second, Keith, if you can't make alterations to the base library, then you
might want to look at the "Decorator" pattern. I think it might help here.
Here's one:

http://www.dofactory.com/Patterns/PatternDecorator.aspx

-mdb
Click to expand...


Mark, I think you are absolutely right, the way it is written locks it
in. Here is how the library is written sort of sudo code:

class ADUser
{
public string FirstName;
public string LastName;
public string PictureURL;

public static List<ADUser> GetUsersByName(string firstName,string lastName)
{
// pretend this searched Active directory
// and found two users with the name frank
List<ADUser> users = new List<ADUser>();
users.Add(new ADUser("frank", "wannabe"));
users.Add(new ADUser("frank", "cats"));
return users;
}
}

Based on that, what do you think *should* be done on this?
 
Based on that, what do you think *should* be done on this?
Click to expand...

On that, nothing.

In my first response, I was assuming that the problem was that the library
also provides functions that take a List<ADUser>, and that you cannot use
these functions because you want to derive DataGridUser from ADUser, and
then pass List<DataGridUser> to that function (which doesn't compile.)
This may have been assuming too much.

It seems that you simply want to convert the List<ADUser> to your derived
List<DataGridUser>. If that's the case, then you can use something like
this:

public new List<DataGridUser> GetByName(...)
{
List<ADUser> adUsers = base.GetByName(...)
List<DataGridUser> dgUsers = new List<DataGridUser>(adUsers.ToArray());
return dgUsers;
}

-mdb
 
Michael said:
On that, nothing.

In my first response, I was assuming that the problem was that the library
also provides functions that take a List<ADUser>, and that you cannot use
these functions because you want to derive DataGridUser from ADUser, and
then pass List<DataGridUser> to that function (which doesn't compile.)
This may have been assuming too much.

It seems that you simply want to convert the List<ADUser> to your derived
List<DataGridUser>. If that's the case, then you can use something like
this:

public new List<DataGridUser> GetByName(...)
{
List<ADUser> adUsers = base.GetByName(...)
List<DataGridUser> dgUsers = new List<DataGridUser>(adUsers.ToArray());
return dgUsers;
}

-mdb
Click to expand...

Actually to make you feel better, there are some functions which take
the list List<ADUser> and then do things with that list in the ADUser
object. Those methods need to be re-structured as well it seems.

Thanks Mark, a great help.

-Keith
 
class DataGridUser : ADUser
{

public DataGridUser(ADuser aduser)
{
// presumably you have this ctor.
}

public static List<DataGridUser> GetUsersByName(string firstName,string
lastName)
{
List<ADUser> users = ADUser.GetUsersByName(firstName,lastName);
List<DataGridUser> dgusers = new List<DataGridUser> (users.Size);
foreach(ADUser user in users)
{
dgusers.Add(new DataGridUser(user));
}

return dgusers;
}

Of course, this will have the same expansion problems as the original. TO
make use of Michael's suggestion:

static public void GetUsersByName<T>(List<T> list, string firstName,string
lastName) where T : DataGridUser
{

List<ADUser> users = ADUser.GetUsersByName(firstName,lastName);
foreach(ADUser user in users)
{
list.Add(new T(user));
}
}

This would be call via:
List<DataGridUser> dgusers = new List<DataGridUser> ();
GetUsersByName(dgusers, "John", "Smith");


Now, I'm a little hazy on allowable C# generics syntax, but In C++
templates, we could write that as

static List<T> GetUsersByName<T>(string firstName,string lastName)
{
}

List<DataGridUser> dgusers = GetUsersByName<DataGridUser>("John",
"Smith");

--
Truth,
James Curran
[erstwhile VC++ MVP]

Home: www.noveltheory.com Work: www.njtheater.com
Blog: www.honestillusion.com Day Job: www.partsearch.com
 
Mark, I think you are absolutely right, the way it is written locks it
in. Here is how the library is written sort of sudo code:

class ADUser
{
public string FirstName;
public string LastName;
public string PictureURL;

public static List<ADUser> GetUsersByName(string firstName,string lastName)
{
// pretend this searched Active directory
// and found two users with the name frank
List<ADUser> users = new List<ADUser>();
users.Add(new ADUser("frank", "wannabe"));
users.Add(new ADUser("frank", "cats"));
return users;
}
}

Based on that, what do you think *should* be done on this?
Click to expand...

Well, you haven't shown your DataGridUser class. Does it have a method
GetUsersByName as well?
 
Jon said:
Well, you haven't shown your DataGridUser class. Does it have a method
GetUsersByName as well?
Click to expand...

The DataGridUser class is very simple. To bind to the datagrid, we need
to convert the photo url in ADUser to a Bitmap. So, no, there isn't a
GetUsersByName in DataGridUser.

class DataGridUser : ADUser
{
private Bitmap photo;
public Bitmap Photo
{
get
{
return Some.Common.Lib.GetImageFromURL(this.PhotoURL);
}
}
}
 
Of course, this will have the same expansion problems as the original.
TO make use of Michael's suggestion:

static public void GetUsersByName<T>(List<T> list, string
firstName,string lastName) where T : DataGridUser
{

List<ADUser> users =
ADUser.GetUsersByName(firstName,lastName); foreach(ADUser user
in users) {
list.Add(new T(user));
}
}
Click to expand...

A fine example of why this is likely to be a common problem! I forgot to
even think of doing it myself! :)

However I was unable to get this to work in my own example (using
Person/Farmer, pardon the shift).

public class Person { ... }
public class Farmer : Person { ... }

private static void GetNames<T>(List<T> list) where T : Person
{
Person mike = new Person("mike");

// This doesn't compile
list.Add(mike);
}

with the compiler saying that it can't convert 'Person' to 'T'. Am I
missing something??

-mdb
 
Keith Elder said:
The DataGridUser class is very simple. To bind to the datagrid, we need
to convert the photo url in ADUser to a Bitmap. So, no, there isn't a
GetUsersByName in DataGridUser.

class DataGridUser : ADUser
{
private Bitmap photo;
public Bitmap Photo
{
get
{
return Some.Common.Lib.GetImageFromURL(this.PhotoURL);
}
}
}
Click to expand...

In that case, a call to DataGridUser.GetUsersByName actually compiles
to a call to ADUser.GetUsersByName anyway.

It sounds like you'll either need to convert the returned list, or just
treat every user as an ADUser until you really *need* to treat it as a
DataGridUser, at which point you can use "as" or cast.
 
Michael Bray said:
A fine example of why this is likely to be a common problem! I forgot to
even think of doing it myself! :)

However I was unable to get this to work in my own example (using
Person/Farmer, pardon the shift).

public class Person { ... }
public class Farmer : Person { ... }

private static void GetNames<T>(List<T> list) where T : Person
{
Person mike = new Person("mike");

// This doesn't compile
list.Add(mike);
}

with the compiler saying that it can't convert 'Person' to 'T'. Am I
missing something??
Click to expand...

Absolutely - if you try to add a Person to a List<Farmer>, that
shouldn't work, should it?

I don't know any way of expressing in C# that T must be a *base* class
of Person, rather than *derived* from Person. I'm pretty sure it's
possible in Java, but I'm bad at remembering the syntax there too...

I'll keep an eye out for it though.
 
Absolutely - if you try to add a Person to a List<Farmer>, that
shouldn't work, should it?
Click to expand...

Yeah I think this is another problem of the "wording" but in this case
its the actual (correct) code that is confusing. It just seems strange
that if I receive a List<T> where T: Person that I can't add a 'Person'
to it. But of course you make perfect sense in your example - if I
receive a List<Farmer> (where Farmer: Person) then of course I can't add
a Person to it because not every person is a farmer! (E I E I O).

I guess when one sees "where T: Person" they can ONLY say "T is a
Person" from OUTSIDE the function. When viewed from INSIDE the
function, T is T, and even though whatever T is may be derived from
Person, you can't treat it as a Person directly.

For example, the following compiles:

static Person mike = new Person("mike");
static Farmer john = new Farmer("john", 10);
static Farmer bob = new Farmer("bob", 20);

private static List<T> GetNames<T>() where T: Person
{
List<T> l = new List<T>();

l.Add(mike as T);
l.Add(john as T);
l.Add(bob as T);

return l;
}

private static void Test()
{
List<Person> people = GetNames<Person>();
List<Farmer> farmers = GetNames<Farmer>();
}

Both 'people' and 'farmers' will have 3 entries, but the first entry in
'farmers' is null (as expected). Furthermore, the entry that is null is
'mike', which IS a person, which is what we are specifying T should be.

Inside the function, you really do have to look at T as a macro
replacement more than simply being a Type specifier. Outside the
function, it is definitely a type specifier.

I don't know any way of expressing in C# that T must be a *base* class
of Person, rather than *derived* from Person. I'm pretty sure it's
possible in Java, but I'm bad at remembering the syntax there too...
Click to expand...

I guess in this case making the parameter a List<T> doesn't make
sense... it should simply return List<Person>, or for Keith's example,
it should return a List<ADUser>. But in that case the function isn't
generic, which was the whole point, so it doesn't matter anyway.

My brain hurts now. :)

-mdb
 
Keith said:
I ran into a unique situation today whereby I have a core library that
uses generics to return users from Active Directory. Example:

List<ADUser> users = ADUser.GetByName("First", "Last");

This works great. However, what I need to do is extend the ADUser
object like so:

class DataGridUser : ADUser
{
// add some new properties
// add some new methods for databinding
}

I can't figure out how to extend it though since the GetByName() returns
a List<ADUser>. Trying this doesn't work:

List<DataGridUser> users = DataGridUser.GetByName("First", "Last");

This throws an exception that GetByName cannot convert DataGridUser to
ADUser. What am I missing or doing wrong? Anyone got any ideas?

-Keith
Click to expand...

I took another stab at this a different way thinking I could solve the
problem but I seemed to have run into a snafu with null exception and
casting. Here is what I did to the base library class trying to come up
with a more flexible solution. The problem lies within the
GetUsersByName() where user is always null and cannot be converted.
Anyone see something that I'm missing and a way to fix this?


class ADUser
{
public string FirstName;
public string LastName;

public static List<T> GetUsersByName<T>(string firstName, string
lastName) where T : ADUser
{
List<T> users = new List<T>();
using (DirectorySearcher ds = GetDirectorySearcher())
{
ds.SearchRoot = AD.DirectoryEntry;
ds.PageSize = 100;
ds.Filter = field;
try
{
using (SearchResultCollection result = ds.FindAll())
{
foreach (SearchResult singleResult in result)
{
// LINE BELOW IS THE ONE IN QUESTION
// IT ALWAYS RETURNS user as null
T user = new ADUser(singleResult) as T;
users.Add(user);
}
}
return users;
}
catch (Exception ex)
{
throw new Exception("Something blew up");
}
}
}
}

class DataGridUser : ADUser
{
private Bitmap photo = null;
public Bitmap Photo
{
get
{
if (photo == null) { this.photo
Some.Lib.GetImageFromURL(this.PhotoURL); }
return this.photo;
}
}
}


class WinForm
{
WinForm()
{
List<DataGridUser> users =
ADUser.GetUsersByName<DataGridUser>("frank", String.Empty);
}
}
 
Keith Elder said:
I took another stab at this a different way thinking I could solve the
problem but I seemed to have run into a snafu with null exception and
casting. Here is what I did to the base library class trying to come up
with a more flexible solution. The problem lies within the
GetUsersByName() where user is always null and cannot be converted.
Anyone see something that I'm missing and a way to fix this?
Click to expand...

Yes, it will always be null if T isn't ADUser. Imagine if you'd asked
it to treat "new object()" as a string - it couldn't.

Now, the code you've given doesn't create a new DataGridUser, and
doesn't indicate that you'd *need* to. Where would you be setting the
Photo property anyway?
 
Jon said:
Yes, it will always be null if T isn't ADUser. Imagine if you'd asked
it to treat "new object()" as a string - it couldn't.

Now, the code you've given doesn't create a new DataGridUser, and
doesn't indicate that you'd *need* to. Where would you be setting the
Photo property anyway?
Click to expand...


My bad, the WinForm class should have been:

class WinForm
{
WinForm()
{
List<DataGridUser> users =
DataGridUser.GetUsersByName<DataGridUser>("frank", String.Empty);
}
}

After reading Michaels last post a ways up in this thread, I see there
really isn't a way to not have user returned as the type specified. We
were pretty much typing the same examples it seems.

Unless someone can talk me out of it, I'm going back to:

public static ArrayList GetUsersByName(string firstName, string lastName)
{
ArrayList ar = new ArrayList();
ar.Add(new ADUser());
ar.Add(new ADuser());
return ar;
}

ArrayList users = ADUser.GetUsersByName("frank", String.Empty);

I think this is really more flexible when trying to do inheritance
unless someone can talk me out of it.
 
After reading Michaels last post a ways up in this thread, I see there
really isn't a way to not have user returned as the type specified. We
were pretty much typing the same examples it seems.

Unless someone can talk me out of it, I'm going back to:

public static ArrayList GetUsersByName(string firstName, string lastName)
{
ArrayList ar = new ArrayList();
ar.Add(new ADUser());
ar.Add(new ADuser());
return ar;
}

ArrayList users = ADUser.GetUsersByName("frank", String.Empty);

I think this is really more flexible when trying to do inheritance
unless someone can talk me out of it.
Click to expand...

What does that buy you? You're still not creating any DataGridUsers in
the list. I don't see any advantage.

If you need to create a list of DataGridUsers, use List<DataGridUser>
at that point, and only at that point. If you're going to create a list
which may have some DataGridUsers and some plain ADUsers in, you might
as well use a List<ADUser> and check each element.
 
Back
Top