String Array to Int Array

[AMP]

Hello
I get 2 errors in the following code that I cant Debug without some
help.
They are both in the TryParse function. Seems simple enough.The Errors
are Below.
private void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = new uint[CardsToBeSorted Array.Length];
foreach (string Card in CardsToBeSorted Array)
{
UInt32.TryParse (Card, out IntCard);

}

}

Error 1 The best overloaded method match for 'uint.TryParse( string, out
uint)' has some invalid arguments
Error 2 Argument '2': cannot convert from 'out uint[]' to 'out uint'

I would appreciate some enlightening
Thanks
Mike

[Dustin Campbell]

Hello

I get 2 errors in the following code that I cant Debug without some
help.
They are both in the TryParse function. Seems simple enough.The Errors
are Below.
private void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = new uint[CardsToBeSorted Array.Length];
foreach (string Card in CardsToBeSorted Array)
{
UInt32.TryParse (Card, out IntCard);
}

}

Error 1 The best overloaded method match for 'uint.TryParse( string,
out
uint)' has some invalid arguments
Error 2 Argument '2': cannot convert from 'out uint[]' to 'out uint'
I would appreciate some enlightening

You can't pass a uint[] where only a uint is expected. You have to do this:

private void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = new uint[CardsToBeSorted Array.Length];
for (int i = 0; i < CardsToBeSorted Array.Length; i++)
UInt32.TryParse (CardsToBeSorte dArray[i], out IntCard[i]);
}

But, since you're using .NET Framework 2.0, you might try using the Array.ConvertAl l<TInput,
TOutputmethod instead:

private static void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = Array.ConvertAl l<string, uint>(CardsToBe SortedArray, delegate(string
card)
{
uint result;
UInt32.TryParse (card, out result);
return result;
});
}
Best Regards,
Dustin Campbell
Developer Express Inc.

[Tom Porterfield]

AMP wrote:

Hello
I get 2 errors in the following code that I cant Debug without some
help.
They are both in the TryParse function. Seems simple enough.The Errors
are Below.
private void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = new uint[CardsToBeSorted Array.Length];
foreach (string Card in CardsToBeSorted Array)
{
UInt32.TryParse (Card, out IntCard);

}

}

Error 1 The best overloaded method match for 'uint.TryParse( string, out
uint)' has some invalid arguments
Error 2 Argument '2': cannot convert from 'out uint[]' to 'out uint'

As the second error states, TryParse needs a 'out uint' as its second
parameter, you are passing 'out uint[]'. You need to pass a specific index
of the array. I would rework the loop as follows:

private void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = new uint[CardsToBeSorted Array.Length];
for (int i = 0; i < CardsToBeSorted Array.Length; i++)
{
uint.TryParse(C ardsToBeSortedA rray[i], out IntCard[i]);
}
}
--
Tom Porterfield

[Tom Porterfield]

Dustin Campbell wrote:

You can't pass a uint[] where only a uint is expected. You have to do
this:
private void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = new uint[CardsToBeSorted Array.Length];
for (int i = 0; i < CardsToBeSorted Array.Length; i++)
UInt32.TryParse (CardsToBeSorte dArray[i], out IntCard[i]);
}

But, since you're using .NET Framework 2.0, you might try using the
Array.ConvertAl l<TInput, TOutputmethod instead:

private static void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = Array.ConvertAl l<string, uint>(CardsToBe SortedArray,
delegate(string card)
{
uint result;
UInt32.TryParse (card, out result);
return result;
});
}

Help me understand something. The second implementation is more code,
requires generics and delegates, and is harder to read, than the first. So
what are the advantages of doing it that way?
--
Tom Porterfield

[Dustin Campbell]

Dustin Campbell wrote:

>

>You can't pass a uint[] where only a uint is expected. You have to do
this:
private void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = new uint[CardsToBeSorted Array.Length];
for (int i = 0; i < CardsToBeSorted Array.Length; i++)
UInt32.TryPars e(CardsToBeSort edArray[i], out IntCard[i]);
}
But, since you're using .NET Framework 2.0, you might try using the
Array.ConvertA ll<TInput, TOutputmethod instead:

private static void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = Array.ConvertAl l<string, uint>(CardsToBe SortedArray,
delegate(strin g card)
{
uint result;
UInt32.TryPars e(card, out result);
return result;
});
}

Help me understand something. The second implementation is more code,
requires generics and delegates, and is harder to read, than the
first. So what are the advantages of doing it that way?

You gave several reasons against the second version. I'll address each:

1. The second implementation is more code.

Yes, the second version contains 14 more characters and two more lines. However,
it removes a loop that is arguably difficult to read. I used an anonymous
method to keep the code in one method so that comparisans could be made.
In reality, I might write it like this:

private uint CardToUInt32(st ring card)
{
uint result;
UInt32.TryParse (card, out result);
return result;
}
private void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = Array.ConvertAl l<string, uint>(CardsToBe SortedArray, CardToUInt32);
}

That pushes the anonymous method into its own method and promotes reuse and
increases readability.

Note that there are very strong reasons to use anonymous methods in some
cases because they actually reduse code.

2. Requires generics and delegates.

I fail to see how using language features in C# 2.0 is a disadvantage as
it is clear that the code in the original post is using .NET Framework 2.0.
You can tell because UInt32.TryParse () is being used. That didn't exist before
2.0.

3. It's harder to read.

True. As best practice, code that uses an anonymous method for good reason
(e.g. to create a closure) should be moved to its own method. But, if you
look at the code that I posted for point #1, it is easy to create a situation
where the code is actually much better than falling back on a for-loop. It's
true that the for-loop is marginally faster but the difference is quite small.

Best Regards,
Dustin Campbell
Developer Express Inc.

[Christof Nordiek]

"Dustin Campbell" <du*****@no-spam-pleasedevexpres s.comschrieb im
Newsbeitrag news:c1******** *************** ***@news.micros oft.com...
<snip>

private static void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = Array.ConvertAl l<string, uint>(CardsToBe SortedArray,
delegate(string card) {
uint result;
UInt32.TryParse (card, out result);
return result;
});
}

Could also be written as:

private static void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = Array.ConvertAl l<string, uint>(CardsToBe SortedArray,
delegate(string
card)
{ retun UInt32.TryParse (card, out result);});
}

[Christof Nordiek]

"Tom Porterfield" <tp******@mvps. orgschrieb im Newsbeitrag
news:OY******** ******@TK2MSFTN GP06.phx.gbl...

Dustin Campbell wrote:

>You can't pass a uint[] where only a uint is expected. You have to do
this:
private void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = new uint[CardsToBeSorted Array.Length];
for (int i = 0; i < CardsToBeSorted Array.Length; i++)
UInt32.TryParse (CardsToBeSorte dArray[i], out IntCard[i]);
}

But, since you're using .NET Framework 2.0, you might try using the
Array.ConvertA ll<TInput, TOutputmethod instead:

private static void ConvertLabelStr ingToArray(stri ng p)
{
string[] CardsToBeSorted Array = p.Split(' ');
uint[] IntCard = Array.ConvertAl l<string, uint>(CardsToBe SortedArray,
delegate(strin g card)
{
uint result;
UInt32.TryParse (card, out result);
return result;
});
}

Help me understand something. The second implementation is more code,
requires generics and delegates, and is harder to read, than the first.
So what are the advantages of doing it that way?

If you find it harder to read, simply don't use it. ;-)

[Marc Gravell]

No it couldn't; uint.TryParse returns a bool, where-as Converter<strin g,
uintmust accept a string and return a uint. It is not compatible.

Marc

[Tom Porterfield]

On Wed, 29 Nov 2006 11:37:36 +0100, Christof Nordiek wrote:

If you find it harder to read, simply don't use it. ;-)

That's one of the poorest excuses I've heard to not use something.
--
Tom Porterfield

[Marc Gravell]

I'm not so convinced in this case...

Look at the pros and cons of doing it this way...

pros: none; previous example showed it was very simple to do in another
(very clear) way
cons: harder to read *PLUS* all the other (very valid) comments [although
generics at least should be ubiquitious by now]

So if it doesn't gain you anything, but makes the code more complex and
hence probably both buggier (see TryParse anti-example) and harder to
debug... doesn't that just shout *do it the easy way!*

Granted there are definite cases for using delegates and methods such as
ConvertAll<>, but I'm not sure that this is one of them, and as such I would
counter "poorest excuse" with "most sensible design decision".

Marc