My attempt at Generics

  • Thread starter Thread starter craigclister
  • Start date Start date
C

craigclister

Hi guys.

I am trying to make a generic function that allows me to search a
ComboBox for a specific item. As it can be used on different combo
boxes, which have items defined as different onject types, I am trying
this:


private int FindItem<Object>(ComboBox cmb, int IdToFind)
{
for (int i = 0; i <= cmb.Items.Count; i++)

{
if (cmb.Items is Object)
{
if ((cmb.Items as Object).Id == IdToFind)
{
return i;
}
}
}
return -1;
}


Then to use this function, I would use this:

cbManufacturer.SelectedIndex = FindItem<OManufacturer>(cbManufacturer,
_product.ManufacturerId);

cbManufacturer is a ComboBox. Each item is of type OManufacturer. I
have another combon on the same form called cbMeasurements which is
made up of objects of type OMeasurements. Both classes have a key as
Id. So I am trying to go through each item in the ComboBox, and mach
the 'IdToFind' with the primary key ID in the object.

It's failing though... Because:
The type parameter 'Object' cannot be used with the 'as' operator
because it does not have a class type constraint nor a 'class'
constraint \frmProductEdit.cs

Could someone assist?
 
Then to use this function, I would use this:

cbManufacturer.SelectedIndex = FindItem<OManufacturer>(cbManufacturer,
_product.ManufacturerId);

cbManufacturer is a ComboBox. Each item is of type OManufacturer. I
have another combon on the same form called cbMeasurements which is
made up of objects of type OMeasurements. Both classes have a key as
Id. So I am trying to go through each item in the ComboBox, and mach
the 'IdToFind' with the primary key ID in the object.

It's failing though... Because:
The type parameter 'Object' cannot be used with the 'as' operator
because it does not have a class type constraint nor a 'class'
constraint \frmProductEdit.cs

Could someone assist?
Click to expand...

First off, your use of "Object" as the type parameter name is highly
confusing - just make it "T". "Object" usually refers to the
System.Object type.

However, I don't really think you need to make the method generic. Just
create an interface with the Id property, make both OManufacturer and
OMeasurements implement it (and preferrably remove the unconventional O
prefix at the same time), and then change your code to use the
interface. No need for generics here, unless you have a combo box with
a mixture of things in it.
 
First, I'd stay away from names like "Object" - it gets very easy to
confuse with System.Object.

* Most stype-arguments start with T for this purpose, and when there
is only a single argument, they are commonly just called T.
* you aren't going to be able to talk about the Id unless you tell it
somehow about the Id, most commonly by an interface or base class -
but once you've done this, the type-argument becomes redundant, as you
aren't actually using any of that extra data.
* I'd probably just use foreach here
* The "as" could just be a cast
* The method may as well be static - it isn't using any local state
* Since the only thing you are using from the combo-box is the list,
perhaps use that directly?

Perhaps something like:

interface IHaveId {
int Id { get; }
}

// your objects would need to implement IHaveId

static int FindItem(IEnumerable list, int id)
{
int index = 0;
foreach(object item in list)
{
if (item is IHaveId) {
if(((IHaveId)item).Id == id) return index;
}
index++;
}
return -1; // not found
}

There are also some other approaches you could take that would make
reasonable use of generics; for instance, passing a predicate into the
function (without requiring a common base-class/etc):

class MyObj {
public int Id { get; set; }
}
static int IndexOf<T>(this IEnumerable<T> list,
Func<T, bool> predicate)
{
int index = 0;
foreach(T item in list)
{
if (predicate(item)) return index;
index++;
}
return -1; // not found
}
combobox1.Items.Cast<MyObj>().IndexOf(x => x.Id == 5);

Marc
 
By the way; to clarify, it would have been possible to use:

static int FindItem(IEnumerable<IHaveId> list, int id)
{
int index = 0;
foreach(IHaveId item in list)
{
if(item.Id == id) return index;
index++;
}
return -1; // not found
}

However, the problem is that this wouldn't be usable with
ComboBox.Items, unless you have the handy LINQ Cast<T> method; and if
you have the Cast<T>, then the predicate approach gets a lot more
tempting instead since it doesn't demand a common interface / base
class, and can work on any property (or set of properties)...

Marc
 
Thanks!
OK, as I am trying to learn the basicas of Generics, I am trying that
route for now.

I seem to have achieved the desired results with this:

cbManufacturer.SelectedIndex =
FindItem<OManufacturer>(cbManufacturer, _product.ManufacturerId);
cbMeasure.SelectedIndex =
FindItem<OMeasurement>(cbMeasure, _product.MeasurementId);

That's the two calls to search two different combos, based on two
different Object types. I have also created an Interface for my
objects, that require the classes to make us of a int Id.

I have this as the Find function now:

private int FindItem<Object>(ComboBox cmb, int IdToFind)
{
for (int i = 0; i <= cmb.Items.Count; i++)
{
if (cmb.Items is IShopperType)
{
if (((IShopperType)cmb.Items).Id == IdToFind)
{
return i;
}
}
}
return -1;
}

And this is working 100%, I think. Is there any reason not to do it
this way? Overkill?
 
Well, the name "Object" has been picked up separately twice;
honestly - don't do this ;-p

The end of the loop is wrong; it should be <, not <= (you will get an
index-out-of-range-exception if the item isn't in the list)

But quite simply, you aren't using the generics in here... you could
perhaps add a constraint using the generic, but I'm not sure it would
help a lot since you would still allow any ComboBox in, regardless of
what the items are. I would drop the generic completely; your code
will still work (you aren't using it, so why code it?).

Marc
 
Back
Top