Jon Skeet: Coding Blog - All Comments

re: Mapping from a type to an instance of that type

skeet — Sun, 12 Oct 2008 18:18:01 GMT

Pavel: I've had another look at KeyedByTypeCollection, and it does look somewhat like it, yes. It's a shame the docs are so poor. (It's really unclear what it's actually doing to start with.)

Personally I prefer the API of DictionaryByType - it makes it clearer what's going on, IMO, and it doesn't artificially implement the other collection interfaces (which can't really express what's going on cleanly). My class also has an interface close to the Dictionary API, with TryGetValue for example. (I'd have used an indexer instead of Get/Put, but they can't be generic.)

Worth knowing about, though - thanks.

re: Mapping from a type to an instance of that type

Pavel Minaev — Sun, 12 Oct 2008 17:06:35 GMT

TItem that you give is the common base type for all types in the collection. Naturally, you can just use Object if you don't want any restrictions whatsoever (which is rare - more often, when you use such a thing as e.g. a factory class registry, you have some common base interface you want to enforce). But otherwise it's precisely the same - the key for the item is its type as returned by GetType(), and there can only be one item of a given type. E.g.:

using System;

using System.Collections.Generic;

static class Program

{

static void Main()

{

var d = new KeyedByTypeCollection<object>();

d.Add(123);

d.Add(123.456);

d.Add('x');

d.Add("foo");

Console.WriteLine(d.Find<int>());

Console.WriteLine(d.Find<double>());

Console.WriteLine(d.Find<char>());

Console.WriteLine(d.Find<string>());

d.Remove<int>();

d.Remove<double>();

d.Remove<string>();

d.Add('y'); // throws

}

re: Mapping from a type to an instance of that type

skeet — Sun, 12 Oct 2008 15:38:05 GMT

Pavel: I can't say I've used KeyedByTypeCollection before, but it looks like the values are all the same type (TItem) as opposed to the value for a particular key being an instance of that key (type).

re: Mapping from a type to an instance of that type

Pavel Minav — Sun, 12 Oct 2008 14:44:22 GMT

Isn't the stock KeyedByTypeCollection<T> class designed to solve precisely this problem?

re: Formatting strings

Pavel Minaev — Fri, 10 Oct 2008 14:35:21 GMT

Interestingly, that's one case where F# ML curring functions allow for smoother syntax. You could curry Format with the format string, and if the implementation is smart, it will parse it at that point (or, alternatively, parse it first time it's needed, but then memoize it). Then you save the function that is the result of that currying, and use it. I.e.:

// Core functionality

type ParsedFormatString = ...

let ParseFormatString s = ...

let FormatPreparsed parsedFormatString args = ...

// BCL-style Format on top of that, with currying and memoization

let Format formatString = FormatPreparsed (ParseFormatString formatString)

...

// Parse as usual

for x = 1 to 10 do

for y = 1 to 10 do

Format "{0} {1}" x y

...

// Memoize and reuse

let FormatPair = Format "{0} {1}"

for x = 1 to 10 do

for y = 1 to 10 do

FormatPair x y

Why should I use List and not ArrayList

Helper Code — Fri, 10 Oct 2008 11:34:14 GMT

I came upon a questing at StackOverflow : The system I work on here was written before .net 2.0 and didn't

re: Why boxing doesn't keep me awake at nights

skeet — Thu, 09 Oct 2008 22:20:16 GMT

Ben: Absolutely. It should have been called "SINGLE_BOX" or something like that. I noticed it after I'd already done everything else, I'm afraid :(

re: Mapping from a type to an instance of that type

skeet — Thu, 09 Oct 2008 22:04:51 GMT

Ben: That limits you to a single type/value mapping. DictionaryByType lets you have as many dictionaries as you want.

re: Why boxing doesn't keep me awake at nights

Ben Voigt [C++ MVP] — Thu, 09 Oct 2008 21:59:23 GMT

Ummm, I think the _NO_BOXING version is misnamed. Surely this line:

object o = i;

involves boxing?

Of course the new C++0x variable template typeargs will put an end to this discussion for a while (because all the ToString calls inside Format can be statically bound to the correct version in the C++0x version and even inlined). This will give the first version the performance of the last one. Well, maybe only the FORMAT_STRINGS version, still over 3x faster.

re: Mapping from a type to an instance of that type

Ben Voigt [C++ MVP] — Thu, 09 Oct 2008 21:52:38 GMT

Jon,

What advantage does your method have over generic statics?

public static class OneAndOnly

{

private static class Content<T>

{

static bool HasValue;

static T Value;

}

public void Add<T>(T value)

{

if (Content<T>.HasValue)

throw new DuplicateKeyException();

Put(value);

}

public void Put<T>(T value)

{

Content<T>.Value = value;

Content<T>.HasValue = true;

}

public T Get<T>()

{

if (Content<T>.HasValue)

throw new KeyNotFoundException();

return Content<T>.Value;

}

public bool TryGet<T>(out T value)

{

value = Content<T>.Value;

return Content<T>.HasValue;

}

public void Remove<T>()

{

Content<T>.HasValue = false;

}

re: Mapping from a type to an instance of that type

SeeR — Thu, 09 Oct 2008 21:48:59 GMT

That was me the guy who asked that question on stackoverflow an I think I found the solution.

See my blog seermindflow.blogspot.com/.../is-it-possible-to-write-c-application.html

or my answer on stackoverflow

re: Mapping from a type to an instance of that type

Todd — Thu, 09 Oct 2008 17:29:06 GMT

With a traditional dictionary it seems much more clear who is the owner of the lifetime of the objects within the dictionary. In the case of a dictionary that contains the sole reference to IDisposables it is obvious that they all need to be disposed when the dictionary is no longer needed.

It seems like with this dictionary the benefit partially lies in the ability of not knowing what people would put in it.

The main reason why IDisposable came to mind was that the StackOverflow post adds a SqlConnection to the dictionary.

Maybe my real concern is that this type of dictionary is not suitable for IDisposables at all, or at least not database connections. Maybe it would seem more correct if it was an object that created database connections.

Qué es más rapido: String.Format o String.Concat?

.NET a 2.860 metros de altura — Thu, 09 Oct 2008 17:28:29 GMT

Esta es una pregunta que he tenido pendiente mucho tiempo. En general yo prefiero usar String.Format

re: Why boxing doesn't keep me awake at nights

Granville Barnett — Thu, 09 Oct 2008 17:25:37 GMT

@David - I look at books as being a catalyst for further investigation.

Maybe my approach is this because the books I tend to read are not as clear cut like most programming books are. This is just the way I feel about them in general.

re: Mapping from a type to an instance of that type

skeet — Thu, 09 Oct 2008 16:28:43 GMT

Todd: The dictionary shouldn't care about any more than the .NET Dictionary class cares if you add references to IDisposable instances. It's up to the client to clean up.

re: Mapping from a type to an instance of that type

Todd — Thu, 09 Oct 2008 16:14:37 GMT

What do you do when someone decides to store an IDisposable object in this dictionary? Should this dictionary be disposable and dispose of any disposable values when the time is appropriate?

re: Formatting strings

skeet — Thu, 09 Oct 2008 15:15:08 GMT

@Richard: I certainly wouldn't suggest doing that. But I'd suggest doing:

sb.Append(x);

sb.Append(":");

sb.Append(y);

instead of

sb.AppendFormat("{0}:{1}", x, y);

(If performance were an issue, of course.)

re: Formatting strings

Richard — Thu, 09 Oct 2008 15:06:43 GMT

As for the relative efficiency of String.Format versus StringBuilder.AppendFormat, have a look at the code for the String.Format(IFormatProvider, string, params object[]) method:

public static string Format(...)

{

...

StringBuilder builder = new StringBuilder(format.Length + (args.Length * 8));

builder.AppendFormat(provider, format, args);

return builder.ToString();

}

Clearly, if you already have a StringBuilder, it's more efficient to call AppendFormat than Append(String.Format).

The only caveat is if the format string is invalid: AppendFormat will append the start of the format string, and then throw an exception, whereas Append(String.Format) will throw an exception without modifying the StringBuilder instance.

re: Why boxing doesn't keep me awake at nights

David Nelson — Thu, 09 Oct 2008 14:42:10 GMT

@Chris, Granville

Of course you cannot take everything you read in a book as 100% gospel; even good authors sometimes make mistakes and are sometimes just plain wrong.

But at the same time, part of the reason that developers read books is that there is way more out there to learn than they could ever possibly learn on their own through experimentation. The software world is expanding far too quickly, no more so than in the .NET space. So developers read books by people who are supposedly already experienced in a particular topic as an efficient way of assimilating new information. If the author is wrong, or is exaggerating, then the reader is assimilating WRONG information, which undermines the point of reading the book in the first place. Sure, the reader could go out and verify everything he reads for himself, but then what is the point of reading the book?

That is why it is so important for authors to make every effort to be as accurate as possible; like it or not, what they say is often the first and possibly the last impression that a developer will get on a particular subject, and if they care at all about being positive contributors to the development community, they need to do their best to make sure that impression is the right one.

re: Why boxing doesn't keep me awake at nights

skeet — Thu, 09 Oct 2008 13:24:03 GMT

Yup, that's the book I'll be getting when it's available in the US. I think they've changed the title though - it used to include the word "Annotated" right there.

I already have the 2.0 edition, signed by Anders, Scott and Peter :)