Generics - A question on generics - delegates - runtime binding.

[bigtexan]

I would like to do the following and cannot figure it out.

public class A<T>
{
public delegate T GetValueDelegat e(A<T> var);
public GetValueDelegat e GetValue = new GetValueDelegat e(B.GetValue);
}

public class B
{
public static int GetValue(A<int> var)
{
//do something and return int
}

public static float GetValue(A<floa t> var)
{
//do something and return float
}

public static string GetValue(A<stri ng> var)
{
//do something and return string
}

//or in general
public static SomeType GetValue(A<Some Type> var)
{
//do something specific for type SomeType and return that SomeType
}
}

Now:-----------------------------------
I was thinking when I do

....somewhere in some code....
A<int> s = new A<int>();

that on creation of this instance of A of type int that the delegate
in A would find the proper overload in class B such that:
....
int I = s.GetValue();
....
would resolve to the class B's method
....
public static int GetValue(A<int> var)
....
and this would occur dynamically at runtime.
The short is that I get a 'No Overload Error' as follows.
'No overload for 'GetValue' matches delegate 'A<T>.GetValueD elegate'

I am obviously not understanding something. Help would be greatly appriciated.

k
--
A single 20-watt compact fluorescent lamp used in place of a 75-watt
incandescent will save about 550 kilowatt-hours over its lifetime. That is
500 pounds of coal; a pile the size of your office desk.

[Siva M]

You have not defined a overload for GetValue in class B that takes no
parameters. But, you are calling it in class A<T>.

"bigtexan" <bi******@onlin e.nospam> wrote in message
news:37******** *************** ***********@mic rosoft.com...
I would like to do the following and cannot figure it out.

public class A<T>
{
public delegate T GetValueDelegat e(A<T> var);
public GetValueDelegat e GetValue = new GetValueDelegat e(B.GetValue);
}

public class B
{
public static int GetValue(A<int> var)
{
//do something and return int
}

public static float GetValue(A<floa t> var)
{
//do something and return float
}

public static string GetValue(A<stri ng> var)
{
//do something and return string
}

//or in general
public static SomeType GetValue(A<Some Type> var)
{
//do something specific for type SomeType and return that SomeType
}
}

Now:-----------------------------------
I was thinking when I do

....somewhere in some code....
A<int> s = new A<int>();

that on creation of this instance of A of type int that the delegate
in A would find the proper overload in class B such that:
....
int I = s.GetValue();
....
would resolve to the class B's method
....
public static int GetValue(A<int> var)
....
and this would occur dynamically at runtime.
The short is that I get a 'No Overload Error' as follows.
'No overload for 'GetValue' matches delegate 'A<T>.GetValueD elegate'

I am obviously not understanding something. Help would be greatly
appriciated.

k
--
A single 20-watt compact fluorescent lamp used in place of a 75-watt
incandescent will save about 550 kilowatt-hours over its lifetime. That is
500 pounds of coal; a pile the size of your office desk.

[Siva M]

You have not defined a overload for GetValue in class B that takes no
parameters. But, you are calling it in class A<T>.

"bigtexan" <bi******@onlin e.nospam> wrote in message
news:37******** *************** ***********@mic rosoft.com...
I would like to do the following and cannot figure it out.

public class A<T>
{
public delegate T GetValueDelegat e(A<T> var);
public GetValueDelegat e GetValue = new GetValueDelegat e(B.GetValue);
}

public class B
{
public static int GetValue(A<int> var)
{
//do something and return int
}

public static float GetValue(A<floa t> var)
{
//do something and return float
}

public static string GetValue(A<stri ng> var)
{
//do something and return string
}

//or in general
public static SomeType GetValue(A<Some Type> var)
{
//do something specific for type SomeType and return that SomeType
}
}

Now:-----------------------------------
I was thinking when I do

....somewhere in some code....
A<int> s = new A<int>();

that on creation of this instance of A of type int that the delegate
in A would find the proper overload in class B such that:
....
int I = s.GetValue();
....
would resolve to the class B's method
....
public static int GetValue(A<int> var)
....
and this would occur dynamically at runtime.
The short is that I get a 'No Overload Error' as follows.
'No overload for 'GetValue' matches delegate 'A<T>.GetValueD elegate'

I am obviously not understanding something. Help would be greatly
appriciated.

k
--
A single 20-watt compact fluorescent lamp used in place of a 75-watt
incandescent will save about 550 kilowatt-hours over its lifetime. That is
500 pounds of coal; a pile the size of your office desk.

[bigtexan]

Thank you for the reply but I do not think that is the reason. The delegate
in class A is defined with the signature. It is this signature that should
match against the methods in class B. And the methods in B do match.

public delegate T GetValueDelegat e(A<T> var);

thanks, but I am still missing something.

[bigtexan]

Thank you for the reply but I do not think that is the reason. The delegate
in class A is defined with the signature. It is this signature that should
match against the methods in class B. And the methods in B do match.

public delegate T GetValueDelegat e(A<T> var);

thanks, but I am still missing something.

[Bernhard Huemer]

Hello,

//or in general
public static SomeType GetValue(A<Some Type> var)
{
//do something specific for type SomeType and return that SomeType
}
I think you've supposed GetValue to be a generic method but it
isn't. Therefore no signature matches the on of your delegate.

public class B
{
// ...

public static SomeType GetValue<SomeTy pe>(A<SomeType> var)
{
// ...
}
}

Btw. the overloaded versions won't get called, whether the signature
matches or not.

greets
On Fri, 22 Jul 2005 18:05:02 +0200, bigtexan <bi******@onlin e.nospam>
wrote: I would like to do the following and cannot figure it out.

public class A<T>
{
public delegate T GetValueDelegat e(A<T> var);
public GetValueDelegat e GetValue = new GetValueDelegat e(B.GetValue);
}

public class B
{
public static int GetValue(A<int> var)
{
//do something and return int
}

public static float GetValue(A<floa t> var)
{
//do something and return float
}

public static string GetValue(A<stri ng> var)
{
//do something and return string
}

//or in general
public static SomeType GetValue(A<Some Type> var)
{
//do something specific for type SomeType and return that SomeType
}
}

Now:-----------------------------------
I was thinking when I do

...somewhere in some code....
A<int> s = new A<int>();

that on creation of this instance of A of type int that the delegate
in A would find the proper overload in class B such that:
...
int I = s.GetValue();
...
would resolve to the class B's method
...
public static int GetValue(A<int> var)
...
and this would occur dynamically at runtime.
The short is that I get a 'No Overload Error' as follows.
'No overload for 'GetValue' matches delegate 'A<T>.GetValueD elegate'

I am obviously not understanding something. Help would be greatly
appriciated.

k

[Bernhard Huemer]

Hello,

//or in general
public static SomeType GetValue(A<Some Type> var)
{
//do something specific for type SomeType and return that SomeType
}
I think you've supposed GetValue to be a generic method but it
isn't. Therefore no signature matches the on of your delegate.

public class B
{
// ...

public static SomeType GetValue<SomeTy pe>(A<SomeType> var)
{
// ...
}
}

Btw. the overloaded versions won't get called, whether the signature
matches or not.

greets
On Fri, 22 Jul 2005 18:05:02 +0200, bigtexan <bi******@onlin e.nospam>
wrote: I would like to do the following and cannot figure it out.

public class A<T>
{
public delegate T GetValueDelegat e(A<T> var);
public GetValueDelegat e GetValue = new GetValueDelegat e(B.GetValue);
}

public class B
{
public static int GetValue(A<int> var)
{
//do something and return int
}

public static float GetValue(A<floa t> var)
{
//do something and return float
}

public static string GetValue(A<stri ng> var)
{
//do something and return string
}

//or in general
public static SomeType GetValue(A<Some Type> var)
{
//do something specific for type SomeType and return that SomeType
}
}

Now:-----------------------------------
I was thinking when I do

...somewhere in some code....
A<int> s = new A<int>();

that on creation of this instance of A of type int that the delegate
in A would find the proper overload in class B such that:
...
int I = s.GetValue();
...
would resolve to the class B's method
...
public static int GetValue(A<int> var)
...
and this would occur dynamically at runtime.
The short is that I get a 'No Overload Error' as follows.
'No overload for 'GetValue' matches delegate 'A<T>.GetValueD elegate'

I am obviously not understanding something. Help would be greatly
appriciated.

k

[DanGo]

Hey bigguy!

The problem is that A<T> can be instantiated with any Type T. Your B
overloads GetValue for some distinct A<T>'s: A<int>, A<float>, A<string>,
A<SomeType> but there will always be some type T (for example FooBar) that
it does not overload. Generic classes must be able to work for any T you
want to pameterize them with.

This seems to make them nearly useless since the only operations we can
perform on any type T are the ones in the common base class "object"

Enter constraints.

Constraints let us add operations that T can perform by constraining the
type of T

E.g
public class Foo<T> where T : IBar

So now we can use any operations that the IBar interface supports and in
turn we promise that whenever we instantiate a Foo we will pass a T that
implements IBar.

Now the bad news.
Interfaces don't support static members as part of their signature. So we
have no way to constrain the type to say that we will only try to create A<T>
with types that implement T GetValue(A<T>).

So what are you really trying to do?

"bigtexan" wrote:

I would like to do the following and cannot figure it out.

public class A<T>
{
public delegate T GetValueDelegat e(A<T> var);
public GetValueDelegat e GetValue = new GetValueDelegat e(B.GetValue);
}

public class B
{
public static int GetValue(A<int> var)
{
//do something and return int
}

public static float GetValue(A<floa t> var)
{
//do something and return float
}

public static string GetValue(A<stri ng> var)
{
//do something and return string
}

//or in general
public static SomeType GetValue(A<Some Type> var)
{
//do something specific for type SomeType and return that SomeType
}
}

Now:-----------------------------------
I was thinking when I do

...somewhere in some code....
A<int> s = new A<int>();

that on creation of this instance of A of type int that the delegate
in A would find the proper overload in class B such that:
...
int I = s.GetValue();
...
would resolve to the class B's method
...
public static int GetValue(A<int> var)
...
and this would occur dynamically at runtime.
The short is that I get a 'No Overload Error' as follows.
'No overload for 'GetValue' matches delegate 'A<T>.GetValueD elegate'

I am obviously not understanding something. Help would be greatly appriciated.

k
--
A single 20-watt compact fluorescent lamp used in place of a 75-watt
incandescent will save about 550 kilowatt-hours over its lifetime. That is
500 pounds of coal; a pile the size of your office desk.

[DanGo]

Hey bigguy!

The problem is that A<T> can be instantiated with any Type T. Your B
overloads GetValue for some distinct A<T>'s: A<int>, A<float>, A<string>,
A<SomeType> but there will always be some type T (for example FooBar) that
it does not overload. Generic classes must be able to work for any T you
want to pameterize them with.

This seems to make them nearly useless since the only operations we can
perform on any type T are the ones in the common base class "object"

Enter constraints.

Constraints let us add operations that T can perform by constraining the
type of T

E.g
public class Foo<T> where T : IBar

So now we can use any operations that the IBar interface supports and in
turn we promise that whenever we instantiate a Foo we will pass a T that
implements IBar.

Now the bad news.
Interfaces don't support static members as part of their signature. So we
have no way to constrain the type to say that we will only try to create A<T>
with types that implement T GetValue(A<T>).

So what are you really trying to do?

"bigtexan" wrote:

I would like to do the following and cannot figure it out.

public class A<T>
{
public delegate T GetValueDelegat e(A<T> var);
public GetValueDelegat e GetValue = new GetValueDelegat e(B.GetValue);
}

public class B
{
public static int GetValue(A<int> var)
{
//do something and return int
}

public static float GetValue(A<floa t> var)
{
//do something and return float
}

public static string GetValue(A<stri ng> var)
{
//do something and return string
}

//or in general
public static SomeType GetValue(A<Some Type> var)
{
//do something specific for type SomeType and return that SomeType
}
}

Now:-----------------------------------
I was thinking when I do

...somewhere in some code....
A<int> s = new A<int>();

that on creation of this instance of A of type int that the delegate
in A would find the proper overload in class B such that:
...
int I = s.GetValue();
...
would resolve to the class B's method
...
public static int GetValue(A<int> var)
...
and this would occur dynamically at runtime.
The short is that I get a 'No Overload Error' as follows.
'No overload for 'GetValue' matches delegate 'A<T>.GetValueD elegate'

I am obviously not understanding something. Help would be greatly appriciated.

k
--
A single 20-watt compact fluorescent lamp used in place of a 75-watt
incandescent will save about 550 kilowatt-hours over its lifetime. That is
500 pounds of coal; a pile the size of your office desk.

[dubian]

Well,

Actually, I want to do this.

A<any_type> var1 = new A<any_type>();

//set up a etc...

any_type var2 = var1.GetValue() ;

where GetValue is dependant on var2.

Basically, I want a polymorfic collection class that does not need
boxing due to the number of objects I need to create and least of all,
I do not want to write 50 classes, I just want to write 50 GetValue()
methods that return a native type, not an object and thus have to cast
consistantly.

I find it odd that generics are so closely tied to constraints. Sort of
an oxymoronic relationship.

I understand that things need to bind with out exception, however, I
would rather chase a couple of exceptions than manage 50
implimentations of a generic idea. I get tired of subclassing.

And besides, wouldn't it be a compile time error if the type <T> didn't
have a corresponding overload available.

Thanks for your assistance BTH. It is helping me to sort out the
details here.