Question on Method Signatures

[Robert McCall]

Greetings All,

Does anyone have any idea why a method signature does not
include the return type?

Example:

int someFct( int a, int b );

is the same signature as

double someFct( int a, int b );

and, as such, cannot co-exist in a class.

Is there some kind of object-oriented base ~ sub-class
relationship that is helped by not including the return
value in the signature?

Peace & Blessings,
Robert McCall

[Jon Skeet [C# MVP]]

Robert McCall wrote:

Does anyone have any idea why a method signature does not
include the return type?

Because overloading by return type would be really nasty - it would
mean that there would be no such concept as the type of an expression;
it would depend on what was being expected.

I don't *think* that occurs anywhere in C# 1.1. It might to some extent
with C# 2.0 in terms of generics (it does with Java generics), but it's
generally a bad idea, IMO.

For one thing, what would you expect to be called if someone were just
to call the function without *using* the return value?

Jon

[Carlos J. Quintero [VB MVP]]

Because the caller can ignore the function result and the compiler would not
know which function to call. At least using VB.NET you can have:

Call MyFunction(a,b) ;

--

Best regards,

Carlos J. Quintero

MZ-Tools: Productivity add-ins for Visual Studio .NET, VB6, VB5 and VBA
You can code, design and document much faster.
Free resources for add-in developers:
http://www.mztools.com

"Robert McCall" <mi*******@gmai l.com> escribió en el mensaje
news:11******** *************@g 49g2000cwa.goog legroups.com...

Greetings All,

Does anyone have any idea why a method signature does not
include the return type?

Example:

int someFct( int a, int b );

is the same signature as

double someFct( int a, int b );

and, as such, cannot co-exist in a class.

Is there some kind of object-oriented base ~ sub-class
relationship that is helped by not including the return
value in the signature?

Peace & Blessings,
Robert McCall

[Robert McCall]

Thanks Jon (and Carlos below),

Ah, I see now, yet I have occasionally found the desire to
create such functions to prevent my manually having to
call the necessary function (or make the cast) on the
return value.

Of course, one of my general gripes with polymorphic
languages is that each name should be different in some way
to specifiy the *exact* function that is being performed. In
the case of constructors they are not all just "new" functions,
they are all specific variants of a new function whose parameters
purposefully influence how the class is instantiated.

Of course, with a more specific (i.e. non text-based) IDE like
the Intentional Programming environment, selecting the exact
function is required if there is any ambiguity and the link isn't
to the name, but to the actual function definition.

Anyway, thanks for answering my question.

Peace & Blessings,
Robert McCall

[Kevin Spencer]

Using the new Generics in C#, you can declare a Generic method, such as:

public T doSomething<T>( T returnVal)
{
return returnVal;
}

You can also create a method that returns a Generic Type declared as a Type
parameter in the class in which it resides:

/// <summary>
/// Base class for various Dictionaries with string key
/// </summary>
/// <typeparam name="T">Type of Values</typeparam>
public class GenericDictiona ryCollection<T>
: System.Collecti ons.Generic.Dic tionary<String, T>
{

/// <summary>
/// Overridable default Item method
/// </summary>
/// <param name="key">key of Item</param>
/// <returns>Valu e of Item</returns>
new virtual public T this[string key]
{
get { return base[key]; }
set
{
base[key] = value;
}
}

//...
}

--
HTH,

Kevin Spencer
Microsoft MVP
..Net Developer
A watched clock never boils.

"Jon Skeet [C# MVP]" <sk***@pobox.co m> wrote in message
news:11******** **************@ z14g2000cwz.goo glegroups.com.. .

Robert McCall wrote:

Does anyone have any idea why a method signature does not
include the return type?

Because overloading by return type would be really nasty - it would
mean that there would be no such concept as the type of an expression;
it would depend on what was being expected.

I don't *think* that occurs anywhere in C# 1.1. It might to some extent
with C# 2.0 in terms of generics (it does with Java generics), but it's
generally a bad idea, IMO.

For one thing, what would you expect to be called if someone were just
to call the function without *using* the return value?

Jon

[Jon Skeet [C# MVP]]

Kevin Spencer <ke***@DIESPAMM ERSDIEtakempis. com> wrote:

Using the new Generics in C#, you can declare a Generic method, such as:

public T doSomething<T>( T returnVal)
{
return returnVal;
}

But could you do:

public T doSomething<T where T:new()>()
{
return new T(); // Whatever the syntax is - can't remember offhand
}

Then:

object o = doSomething();
MemoryStream m = doSomething();

You can in Java with scary amounts of type inference. Not sure I
entirely approve, to be honest...

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too

[Jay B. Harlow [MVP - Outlook]]

Jon,
| public T doSomething<T where T:new()>()
Yes you can define a generic function where the parameter is only used for
the return type.

However you need to supply the type parameter when you call the method,
something like:

| object o = doSomething<obj ect>();
| MemoryStream m = doSomething<Mem oryStream>();

However! it "violates" an FxCop rule as its "ambiguous" .

Here is a thread that discusses it:

http://groups.google.com/group/micro...4e46ca8f99b798

Personally I find in the case of GetCustomAttrib ute (as the thread shows) it
makes sense as the type parameter is encapsulating the downcast, plus the
type parameter is used to "do work".

--
Hope this helps
Jay [MVP - Outlook]
..NET Application Architect, Enthusiast, & Evangelist
T.S. Bradley - http://www.tsbradley.net
"Jon Skeet [C# MVP]" <sk***@pobox.co m> wrote in message
news:MP******** *************** *@msnews.micros oft.com...
| Kevin Spencer <ke***@DIESPAMM ERSDIEtakempis. com> wrote:
| > Using the new Generics in C#, you can declare a Generic method, such as:
| >
| > public T doSomething<T>( T returnVal)
| > {
| > return returnVal;
| > }
|
| But could you do:
|
| public T doSomething<T where T:new()>()
| {
| return new T(); // Whatever the syntax is - can't remember offhand
| }
|
| Then:
|
| object o = doSomething();
| MemoryStream m = doSomething();
|
| You can in Java with scary amounts of type inference. Not sure I
| entirely approve, to be honest...
|
| --
| Jon Skeet - <sk***@pobox.co m>
| http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
| If replying to the group, please do not mail me too

[Jon Skeet [C# MVP]]

Jay B. Harlow [MVP - Outlook] <Ja************ @tsbradley.net> wrote:

| public T doSomething<T where T:new()>() Yes you can define a generic function where the parameter is only used for
the return type.

However you need to supply the type parameter when you call the method,
something like:

| object o = doSomething<obj ect>();
| MemoryStream m = doSomething<Mem oryStream>();
Oh good. It's always a little bit freaky when it "just works" in Java.
However! it "violates" an FxCop rule as its "ambiguous" .

Here is a thread that discusses it:

http://groups.google.com/group/micro...languages.csha
rp/browse_frm/thread/c96debb32de857b 1/cf4e46ca8f99b79 8#cf4e46ca8f99b 79
8

Personally I find in the case of GetCustomAttrib ute (as the thread shows) it
makes sense as the type parameter is encapsulating the downcast, plus the
type parameter is used to "do work".

Right. Okay, I think all that makes sense - thanks very much :)

--
Jon Skeet - <sk***@pobox.co m>
http://www.pobox.com/~skeet Blog: http://www.msmvps.com/jon.skeet
If replying to the group, please do not mail me too