Converting a Dictionary to an array?

[Gustaf]

This is two questions in one really. First, I wonder how to convert the
values in a Dictionary to an array. Here's the dictionary:

private Dictionary<Uri, Schemaschemas = new Dictionary<Uri, Schema>();

Uri is the System.Uri class, and Schema is a class I made. Now, I want
the class where this Dictionary is contained to have a property that
returns all the values in this Dictionary. Like such:

public Schema[] Schemas

How do I implement this property? I can figure out how to do it, but
that involves looping through all the elements in the dictionary, and
that's probably not the way it's meant to be done. I assume there must
be a one-liner solution, like the ArrayList.ToArr ay() method. I found
the Dictionary.Valu es property, but can't figure out how to make that
into an array.

My second question is about best practices. I wonder if it makes sense
to have a property that returns an array of Schema objects, rather than
returning another kind of collection? I want a basic and general
interface outwards, something that doesn't assume too much in terms of
what packages are used in the calling class. Then, is an object array
the best choice?

Gustaf

[Dave Sexton]

Hi Gustaf,

This is two questions in one really. First, I wonder how to convert the
values in a Dictionary to an array. Here's the dictionary:

private Dictionary<Uri, Schemaschemas = new Dictionary<Uri, Schema>();

Uri is the System.Uri class, and Schema is a class I made. Now, I want the
class where this Dictionary is contained to have a property that returns
all the values in this Dictionary. Like such:

public Schema[] Schemas

How do I implement this property? I can figure out how to do it, but that
involves looping through all the elements in the dictionary, and that's
probably not the way it's meant to be done. I assume there must be a
one-liner solution, like the ArrayList.ToArr ay() method. I found the
Dictionary.Valu es property, but can't figure out how to make that into an
array.

public Schema[] Schemas
{
get
{
Schema[] array = new Schema[schemas.Count];
schemas.Values. CopyTo(array, 0);
return array;
}
}

My second question is about best practices. I wonder if it makes sense to
have a property that returns an array of Schema objects, rather than
returning another kind of collection? I want a basic and general interface
outwards, something that doesn't assume too much in terms of what packages
are used in the calling class. Then, is an object array the best choice?

That depends on what the caller will be doing with the return value, but
most likely an array would be your best choice since it only represents a
copy of the values in your dictionary. Any other return type might be
misleading.

--
Dave Sexton

[Lucian Wischik]

Gustaf <gu*****@algone t.sewrote:

>I found the Dictionary.Valu es property, but can't figure out how to make that
into an array.
My second question is about best practices. I wonder if it makes sense
to have a property that returns an array of Schema objects, rather than
returning another kind of collection? I want a basic and general
interface outwards, something that doesn't assume too much in terms of
what packages are used in the calling class. Then, is an object array
the best choice?

I don't think an object array is the best choice. Dictionary.Valu es
seems perfect for what you need. And I think it's more elegant for
objects to return ICollection<Tor IEnumerable<Tra ther than T[].
(e.g. returning an IEnumerable<Two uld let you completely rewrite
your code for returning the thing, perhaps even using the wonderful
"yield return").

--
Lucian

[Jon Shemitz]

Gustaf wrote:

public Schema[] Schemas

How do I implement this property? I can figure out how to do it, but
that involves looping through all the elements in the dictionary, and
that's probably not the way it's meant to be done. I assume there must
be a one-liner solution, like the ArrayList.ToArr ay() method. I found
the Dictionary.Valu es property, but can't figure out how to make that
into an array.

You can do this as a one-liner, but it's not pretty:

return new List<Schema>(sc hemas.Values).T oArray();

If you don't want to get fired after your next code review, you
probably ought to break this into two statements:

List<SchemaValu es = new List<Schema>(sc hemas.Values);
return Values.ToArray( );

My second question is about best practices. I wonder if it makes sense
to have a property that returns an array of Schema objects, rather than
returning another kind of collection? I want a basic and general
interface outwards, something that doesn't assume too much in terms of
what packages are used in the calling class. Then, is an object array
the best choice?

Probably not. The approach that makes the fewest assumptions and
wastes the fewest cycles is to just expose a

public IEnumerable<Sch emaValues
{
get { return schemas.Values; }
}

Then, if your callers just want to enumerate, they can do so without
any waste of time or memory. If they want a List<Schema>, they can
easily generate one; ditto if they want a Schema[].

--

..NET 2.0 for Delphi Programmers
www.midnightbeach.com/.net
What you need to know.

[Mark Rae]

"Jon Shemitz" <jo*@midnightbe ach.comwrote in message
news:45******** *******@midnigh tbeach.com...

You can do this as a one-liner, but it's not pretty:

return new List<Schema>(sc hemas.Values).T oArray();

If you don't want to get fired after your next code review

I've never understood that attitude at all - there is absolutely *nothing*
wrong with that single line of code...

[Dave Sexton]

Hi Mark,

Well, it's iterating the entire collection to copy it into a new object,
just so it can do another copy internally again to return it as an array,
simply to save 2 lines of code :)

--
Dave Sexton

"Mark Rae" <ma**@markNOSPA Mrae.comwrote in message
news:OC******** ******@TK2MSFTN GP04.phx.gbl...

"Jon Shemitz" <jo*@midnightbe ach.comwrote in message
news:45******** *******@midnigh tbeach.com...

>You can do this as a one-liner, but it's not pretty:

return new List<Schema>(sc hemas.Values).T oArray();

If you don't want to get fired after your next code review

I've never understood that attitude at all - there is absolutely *nothing*
wrong with that single line of code...

[Jon Shemitz]

Mark Rae wrote:

You can do this as a one-liner, but it's not pretty:

return new List<Schema>(sc hemas.Values).T oArray();

If you don't want to get fired after your next code review

I've never understood that attitude at all - there is absolutely *nothing*
wrong with that single line of code...

It's sort of hard to parse, especially if you're a bit unclear on C#
operator precedence. And, imho, you can be a perfectly fine C#
programmer - comfortable with all the operators and idioms - and still
be a bit unclear on C# operator precedence. I mean **15** levels of
precedence? It makes a lot of sense to ignore that and use
"unnecessar y" parens.

--

..NET 2.0 for Delphi Programmers
www.midnightbeach.com/.net
What you need to know.

[Jon Shemitz]

Dave Sexton wrote:

Well, it's iterating the entire collection to copy it into a new object,
just so it can do another copy internally again to return it as an array,
simply to save 2 lines of code :)

Yeah - I was typing under the influence of the impression that Keys
and Values were IEnumerable<T>s , not collections. (It certainly seems
like that would be a better design.)

--

..NET 2.0 for Delphi Programmers
www.midnightbeach.com/.net
What you need to know.

[Fabio Z]

"Dave Sexton" <dave@jwa[remove.this]online.comha scritto nel messaggio
news:eX******** ******@TK2MSFTN GP06.phx.gbl...

Hi Mark,

Well, it's iterating the entire collection to copy it into a new object,
just so it can do another copy internally again to return it as an array,
simply to save 2 lines of code :)

Premised that I also prefere the second solution, I really don't see
difference into generated IL.
I would be more worried about the fact that a class shouldn't return a
Something<Tclas s to the extern.

[Mark Rae]

"Fabio Z" <zn*******@virg ilio.itwrote in message
news:%2******** ********@TK2MSF TNGP02.phx.gbl. ..

Premised that I also prefere the second solution,

That's perfectly fine, but a very different argument...:-)

I really don't see difference into generated IL.

That's because there isn't any, AFAICS

I would be more worried about the fact that a class shouldn't return a
Something<Tclas s to the extern.

:-)