That would certainly explain why you don't see it as a problem - but
please believe that it *is* an issue for those of us who *don't* have a
one second build time.
Understandable, and that would probably lead me to test a bit less
often, depending on how long the build takes.
Now, there's an open question as to quite *why* my builds are taking so
long. If it's that rare, it sounds like it's worth investigating a bit
further. Unfortunately I don't have any projects of any size at home
(although even my small MiscUtil project takes more than a second, if
I've made any changes).
It could be as simple as a slow HD.
My suspicion is that one of our pre-build steps is triggering a rebuild
of all the projects in the solution every time, which would account for
it, but I'll have to see.
That very well could be the issue. As I said, I know my Forms
projects take quite a bit longer, because of all the embedded
resoruces being compiled in.
Wow - I don't think reload takes nearly that long for me, despite the
longer build time. Of course, that's another benefit of Java's "one
file per class" system - there's not a lot to load if you only use a
few classes.
It never used it; a second or two at most. As soon as I upgraded to
2.4, reload time increased. On the NUnit list, it seems other's are
experiencing some performance issues as well. So I'm not sure that
one file per class would help as much. I"m also not sure it would
work in .Net anyway; doesn't NUnit load the tests and tested assemblie
in another appdomain? Once loaded, you'd have to tear down and
recreate the entire appdomain anyway.
If you've got a subsecond build already, then I agree there's no
significant problem (except for reloading, by the sounds of it!).
And that seems to be strictly an NUnit issue, as 2.2.9 was fine.
No - Eclipse doesn't do actual compilation until you save. It spots
some errors, but not all. For instance, if I delete a method that other
classes depend on, it won't produce any errors until I save.
Got ya; saving is actually something that could take some time,
because VS will do a checkout if the file isn't already checked out by
me.. but that's just the first time. I think the vb.net ide will
catch your mentioned error though. From what I"ve heard, anyway ;-)
That would certainly help to keep your build time down - but it does
have other disadvantages. It sounds pretty inconvenient if you have
several projects, and have to open up that many copies of Visual Studio
if you end up changing lots of them. (Does "Go to definition" still let
you bring up source code in your situation, btw? Not having that would
be a major inconvenience for me.)
I usually work on one layer at a time anyway, so I don't leave my
business layer until tests and coding are done. Then I do the UI. I
don't spend much time in my data layer because I generate most of it
off my table definitions. Goto defintion works the same as if you had
done it to a framework class; you get the definition based on the
metadata. Debugging though I can still step into the referenced
assemblies, once I tell vs to load the module and point it to a pdb
and source code location (which it remembers from then on). It can be
an inconvience, but at the same time I try to use my classes as black
boxes (until I try debugging when they aren't working well together)..
build to an interface after all. ;-)
That all sounds good - but you did say that improving compile time was
one of the reasons for changing.
I don't recall where I said that, if you could point me to a post
where I said that I'll check it out. But to be clear here and now, I
never seperated anything to improve compile time; I only did it to
seperate tiers or so that a useful class can be shared among
applications (or other assemblies, if we're talking the lower level
ones). I started out knowing I'd have multiple solutions and projects
and had an idea of what I wanted where.
Yup, you can download a trial for free:
http://www.jetbrains.com/resharper/
I'll go do that, thanks!