why does IndexOf still return -1

[Gordon Cowie]

Wouldn't it make sense if IndexOf just threw a character not found
exception instead of -1?

If -1 is what you were expecting there should be a function ContainsChar
that returns bool.

Thoughts?

[jeremiah johnson]

what's the difference between a known exception and a known return based
on the same input data? your logic to handle the error would very
likely be the same...

personally, as long as i know what happens when i give a particular
function some data, i don't care how it handles something like that. it
could return -3.14159 or throw a YoureAFoolForTr yingThatExcepti on, as
long as its in the documentation.

Gordon Cowie wrote:

Wouldn't it make sense if IndexOf just threw a character not found
exception instead of -1?

If -1 is what you were expecting there should be a function ContainsChar
that returns bool.

Thoughts?

[Gordon Cowie]

jeremiah johnson wrote:

what's the difference between a known exception and a known return based
on the same input data? your logic to handle the error would very
likely be the same...

personally, as long as i know what happens when i give a particular
function some data, i don't care how it handles something like that. it
could return -3.14159 or throw a YoureAFoolForTr yingThatExcepti on, as
long as its in the documentation.

It would be "cleaner" as far as separation of the error-handling type of
code goes. Take, for example this function.

int a = SomeString.Inde xOf("f");
if (a != -1)
{
int b = SomeString.Inde xOf("g");
if (b != -1)
{
int c = SomeString.Subs tring(a,b).Inde xOf("i");
if (c != -1)
{
return(SomeStri ng.Substring(0, c);
}
else
throw InvalidStuff;
}
else
throw InvalidStuff;
}
else
throw InvalidStuff;

phew. now, with exceptions..

try
{
return Somestring.Subs tring(0,
SomeString.Subs tring(
SomeString.Inde xOf("f"),
SomeString.Inde xOf("g")).Index Of("i"));
}
catch(CharNotFo undException e)
{
throw InvalidStuff;
}

cleaner no? no pesky a,b,c variables either.

[Mattias Sjögren]

It would be "cleaner" as far as separation of the error-handling type of
code goes.
But it's not necessarily an error if the string doesn't contain the
specified character.

try
{
return Somestring.Subs tring(0,
SomeString.Subs tring(
SomeString.Inde xOf("f"),
SomeString.Inde xOf("g")).Index Of("i"));
}
catch(CharNotF oundException e)
{
throw InvalidStuff;
}

You can still do it this way, Substring shouold throw if you end up
passing -1 to it.
Mattias

--
Mattias Sjögren [C# MVP] mattias @ mvps.org
http://www.msjogren.net/dotnet/ | http://www.dotnetinterop.com
Please reply only to the newsgroup.

[Mike]

"Gordon Cowie" <go***@dynamics direct.com> wrote in message
news:%2******** *******@TK2MSFT NGP11.phx.gbl.. .

jeremiah johnson wrote: try
{
return Somestring.Subs tring(0,
SomeString.Subs tring(
SomeString.Inde xOf("f"),
SomeString.Inde xOf("g")).Index Of("i"));
}
catch(CharNotFo undException e)
{
throw InvalidStuff;
}

cleaner no? no pesky a,b,c variables either.

Sure, as long as you want to call SubString a bunch if times and throw away
the values :)

I prefer the -1 in this case much more. An exception should be used (IMHO)
for "exceptiona l" circumstances - IndexOf not finding a character is a
"normal" outcome for IndexOf. An execption would be useful if the target
string was null (as it does throw), or if c# strings were kept in native
encodings and they didn't match, etc. Another case is when no "out of band"
sentinal value is possible -- like "int GetNextInt()". Although it's a
matter of taste in most cases, I reckon...

[Peter Rilling]

It would also be far more expensive. Exceptions are very expensive and
really, exceptions are for "exceptiona l" events, things that you normally
would not have control over.

For instance, if you open a socket and the network suddenly shutdown, well,
that is not something your app could have predicted.

"Gordon Cowie" <go***@dynamics direct.com> wrote in message
news:%2******** *******@TK2MSFT NGP11.phx.gbl.. .

jeremiah johnson wrote:

what's the difference between a known exception and a known return based
on the same input data? your logic to handle the error would very likely
be the same...

personally, as long as i know what happens when i give a particular
function some data, i don't care how it handles something like that. it
could return -3.14159 or throw a YoureAFoolForTr yingThatExcepti on, as
long as its in the documentation.

It would be "cleaner" as far as separation of the error-handling type of
code goes. Take, for example this function.

int a = SomeString.Inde xOf("f");
if (a != -1)
{
int b = SomeString.Inde xOf("g");
if (b != -1)
{
int c = SomeString.Subs tring(a,b).Inde xOf("i");
if (c != -1)
{
return(SomeStri ng.Substring(0, c);
}
else
throw InvalidStuff;
}
else
throw InvalidStuff;
}
else
throw InvalidStuff;

phew. now, with exceptions..

try
{
return Somestring.Subs tring(0,
SomeString.Subs tring(
SomeString.Inde xOf("f"),
SomeString.Inde xOf("g")).Index Of("i"));
}
catch(CharNotFo undException e)
{
throw InvalidStuff;
}

cleaner no? no pesky a,b,c variables either.

[Nick Hounsome]

"Gordon Cowie" <go***@dynamics direct.com> wrote in message
news:uS******** ******@TK2MSFTN GP09.phx.gbl...

Wouldn't it make sense if IndexOf just threw a character not found
exception instead of -1?
Not necessarily. In many cases it isn't exceptional.
The real answer is an overload with an extra boolean parameter to indicate
whether you want an exception (You could use a different named method
instead but that would clutter the docs and intellisense more)
If -1 is what you were expecting there should be a function ContainsChar
that returns bool.

No because then if you need the index if it is there but it is optional (a
common case) then you must either incur the exception cost or incur the
search cost twice.

Another reason not to throw exception unless something bad has happened is
that it makes debugging harder - typically when I have a problem I would
tell the debugger to stop on exceptions - If there is one for an
unexceptional case then you need separate exception types and you need to
mess around with telling it which ones to stop for and which not and then
just maybe it really is the source ofthe problem one time. If you use the -1
incorrectly it will usually turn up as an array bounds exception.

[Jon Skeet [C# MVP]]

Peter Rilling <pe***@nospam.r illing.net> wrote:

It would also be far more expensive. Exceptions are very expensive and
really, exceptions are for "exceptiona l" events, things that you normally
would not have control over.

Exceptions aren't nearly as expensive as most people think. See
http://www.pobox.com/~skeet/csharp/exceptions.html
(In this particular case the performance penalty could be significant
in many programs, but I don't want you follow the myth of exception
performance :)

However, they're still wrong in this situation, because it really isn't
exceptional for a character not to be present in a string - it's
something which is almost always a possibility when you use IndexOf, in
my experience. It's rarely an error condition which would make you want
to unwind the stack a significant distance.

Of course, if Gordon wants to write his own method which throws an
exception instead of returning -1, there's nothing to stop him -
whereas if the method already threw an exception, wrapping it in a
method which returned -1 would incur the performance penalty of the
exception.

--
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

[Willy Denoyette [MVP]]

Jon,

Note that Exceptions are significantly more expensive in V2, as shown here:

V1.1
Total time taken: 00:00:32.276803 3
Exceptions per millisecond: 154

V2
Total time taken: 00:02:59.315769 6
Exceptions per millisecond: 27

that means 37 µsecs. per exception, I would say this is more expensive as
some people think ;-)

Willy.
"Jon Skeet [C# MVP]" <sk***@pobox.co m> wrote in message
news:MP******** *************** *@msnews.micros oft.com...
| Peter Rilling <pe***@nospam.r illing.net> wrote:
| > It would also be far more expensive. Exceptions are very expensive and
| > really, exceptions are for "exceptiona l" events, things that you
normally
| > would not have control over.
|
| Exceptions aren't nearly as expensive as most people think. See
| http://www.pobox.com/~skeet/csharp/exceptions.html
| (In this particular case the performance penalty could be significant
| in many programs, but I don't want you follow the myth of exception
| performance :)
|
| However, they're still wrong in this situation, because it really isn't
| exceptional for a character not to be present in a string - it's
| something which is almost always a possibility when you use IndexOf, in
| my experience. It's rarely an error condition which would make you want
| to unwind the stack a significant distance.
|
| Of course, if Gordon wants to write his own method which throws an
| exception instead of returning -1, there's nothing to stop him -
| whereas if the method already threw an exception, wrapping it in a
| method which returned -1 would incur the performance penalty of the
| exception.
|
| --
| 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]]

Willy Denoyette [MVP] <wi************ *@telenet.be> wrote:

Note that Exceptions are significantly more expensive in V2, as shown here:

V1.1
Total time taken: 00:00:32.276803 3
Exceptions per millisecond: 154

V2
Total time taken: 00:02:59.315769 6
Exceptions per millisecond: 27

that means 37 µsecs. per exception, I would say this is more expensive as
some people think ;-)

It's much less expensive than some people think though. There was a
thread on one of the groups a while ago where people were blaming poor
web app performance on the fact that it threw 200 exceptions *per
hour*.

In situations where exceptions are logical to use in the first place
(where usually several levels of stack will be unwound) 37 microseconds
is completely insignificant.

Having said all that, it's surprising just how much slower they are in
2.0...

--
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