Is there a way to view all the errors/warnings of all the classes in a solution?

I guess the subject sayz it all. Is there a way to view all the errors and
warning of all the classes in a solution. It would be nice to have them all
in the task list.

Cheers

Gabriel Lozano-Morán
MCSD .NET
Real Software
http://www.realsoftware.be
http://www.realdn.net


20 comments
Comment actions Permalink

This is an often-requested feature, but it won't be in 2.0. Hopefully
they'll find some way to implement it (even as an option) in some version of
2.x -- ideally some red/yellow/green indicator for each *.cs file in the
solution exporer, and an over-all red/yellow/green indicator for each
project node in the solution explorer. But I don't know how much control
they can have with that. Even if they have to code their own equivalent
solution explorer window, it'd be worth it to get that "birds-eye-view" of
the status of your entire solution, rather than having to open each file...


"Gabriel Lozano-Morán" <gabriel@no-spam.org> wrote in message
news:dsg9nm$uj3$1@is.intellij.net...
>I guess the subject sayz it all. Is there a way to view all the errors and
>warning of all the classes in a solution. It would be nice to have them all
>in the task list.
>

Cheers

>

Gabriel Lozano-Morán
MCSD .NET
Real Software
http://www.realsoftware.be
http://www.realdn.net



0
Comment actions Permalink

It is rather easy to implement this feature.........
But the only REAL problem that we can't incrementally reanalyze solution, so
every change will mean full solution re-analysis.

--
Eugene Pasynkov
Developer
JetBrains, Inc
http://www.jetbrains.com
"Develop with pleasure!"
"Paul Bradshaw" <pbradshaw@advsol.com> wrote in message
news:dsgda6$k61$1@is.intellij.net...

This is an often-requested feature, but it won't be in 2.0. Hopefully
they'll find some way to implement it (even as an option) in some version
of 2.x -- ideally some red/yellow/green indicator for each *.cs file in
the solution exporer, and an over-all red/yellow/green indicator for each
project node in the solution explorer. But I don't know how much control
they can have with that. Even if they have to code their own equivalent
solution explorer window, it'd be worth it to get that "birds-eye-view" of
the status of your entire solution, rather than having to open each
file...

>
>

"Gabriel Lozano-Morán" <gabriel@no-spam.org> wrote in message
news:dsg9nm$uj3$1@is.intellij.net...

>>I guess the subject sayz it all. Is there a way to view all the errors and
>>warning of all the classes in a solution. It would be nice to have them
>>all in the task list.
>>
>> Cheers
>>
>> Gabriel Lozano-Morán
>> MCSD .NET
>> Real Software
>> http://www.realsoftware.be
>> http://www.realdn.net
>>
>



0
Comment actions Permalink

But the only REAL problem that we can't incrementally reanalyze
solution, so
every change will mean full solution re-analysis.


I believe we can implement this. Just it will take some efforts.

Valentin Kipiatkov
Chief Scientist, Vice President of Product Development
JetBrains, Inc
http://www.jetbrains.com
"Develop with pleasure!"

It is rather easy to implement this feature.........
But the only REAL problem that we can't incrementally reanalyze
solution, so
every change will mean full solution re-analysis.



0
Comment actions Permalink

Then how about an option to only show the errors / warnings after a build?
Wouldn't it be easy to implement to just analyze the entire solution the
first time and then only analyze the changed classes one by one?

Gabriel

"Eugene Pasynkov (JetBrains)" <Eugene.Pasynkov@jetbrains.com> wrote in
message news:dsho20$cm7$1@is.intellij.net...

It is rather easy to implement this feature.........
But the only REAL problem that we can't incrementally reanalyze solution,
so every change will mean full solution re-analysis.

>

--
Eugene Pasynkov
Developer
JetBrains, Inc
http://www.jetbrains.com
"Develop with pleasure!"
"Paul Bradshaw" <pbradshaw@advsol.com> wrote in message
news:dsgda6$k61$1@is.intellij.net...

>> This is an often-requested feature, but it won't be in 2.0. Hopefully
>> they'll find some way to implement it (even as an option) in some version
>> of 2.x -- ideally some red/yellow/green indicator for each *.cs file in
>> the solution exporer, and an over-all red/yellow/green indicator for each
>> project node in the solution explorer. But I don't know how much control
>> they can have with that. Even if they have to code their own equivalent
>> solution explorer window, it'd be worth it to get that "birds-eye-view"
>> of the status of your entire solution, rather than having to open each
>> file...
>>
>>
>> "Gabriel Lozano-Morán" <gabriel@no-spam.org> wrote in message
>> news:dsg9nm$uj3$1@is.intellij.net...
>>>I guess the subject sayz it all. Is there a way to view all the errors
>>>and warning of all the classes in a solution. It would be nice to have
>>>them all in the task list.
>>>
>>> Cheers
>>>
>>> Gabriel Lozano-Morán
>>> MCSD .NET
>>> Real Software
>>> http://www.realsoftware.be
>>> http://www.realdn.net
>>>
>>
>>
>



0
Comment actions Permalink

Hello Gabriel Lozano-Morán,

Why just not build solution and have compiler report any errors or warnings?
I understand, that there are some warnings that are detected by Resharper
and not detected by compiler, like redundand casts, etc. But is it so important
to clean them up, until you open a file?

Sincerely,
Ilya Ryzhenkov


G> Then how about an option to only show the errors / warnings after a
G> build? Wouldn't it be easy to implement to just analyze the entire
G> solution the first time and then only analyze the changed classes one
G> by one?
G>
G> Gabriel


0
Comment actions Permalink

Hello Gabriel,

an efficient implementation of solution-wide analysis is involved in any
case. This is something we
may consider for future versions, especially in view of products on the market
(OmniCore, in particular)
that claim to do that.

Regards,
Dmitry Shaporenkov
JetBrains, Inc
http://www.jetbrains.com
"Develop with pleasure!"

Then how about an option to only show the errors / warnings after a
build? Wouldn't it be easy to implement to just analyze the entire
solution the first time and then only analyze the changed classes one
by one?

Gabriel

"Eugene Pasynkov (JetBrains)" <Eugene.Pasynkov@jetbrains.com> wrote in
message news:dsho20$cm7$1@is.intellij.net...

>> It is rather easy to implement this feature.........
>> But the only REAL problem that we can't incrementally reanalyze
>> solution,
>> so every change will mean full solution re-analysis.
>> --
>> Eugene Pasynkov
>> Developer
>> JetBrains, Inc
>> http://www.jetbrains.com
>> "Develop with pleasure!"
>> "Paul Bradshaw" <pbradshaw@advsol.com> wrote in message
>> news:dsgda6$k61$1@is.intellij.net...
>>> This is an often-requested feature, but it won't be in 2.0.
>>> Hopefully they'll find some way to implement it (even as an option)
>>> in some version of 2.x -- ideally some red/yellow/green indicator
>>> for each *.cs file in the solution exporer, and an over-all
>>> red/yellow/green indicator for each project node in the solution
>>> explorer. But I don't know how much control they can have with
>>> that. Even if they have to code their own equivalent solution
>>> explorer window, it'd be worth it to get that "birds-eye-view" of
>>> the status of your entire solution, rather than having to open each
>>> file...
>>>
>>> "Gabriel Lozano-Morán" <gabriel@no-spam.org> wrote in message
>>> news:dsg9nm$uj3$1@is.intellij.net...
>>>
>>>> I guess the subject sayz it all. Is there a way to view all the
>>>> errors and warning of all the classes in a solution. It would be
>>>> nice to have them all in the task list.
>>>>
>>>> Cheers
>>>>
>>>> Gabriel Lozano-Morán
>>>> MCSD .NET
>>>> Real Software
>>>> http://www.realsoftware.be
>>>> http://www.realdn.net


0
Comment actions Permalink

Hello Ilya,

It is important if you work with a large team and have guidelines everybody
should follow.

Gabriel Lozano-Morán
MCSD .NET
Real Software
http://www.realsoftware.be
http://www.realdn.net

Hello Gabriel Lozano-Mor�n,

Why just not build solution and have compiler report any errors or
warnings? I understand, that there are some warnings that are detected
by Resharper and not detected by compiler, like redundand casts, etc.
But is it so important to clean them up, until you open a file?

Sincerely,
Ilya Ryzhenkov

G>> Then how about an option to only show the errors / warnings after a
G>> build? Wouldn't it be easy to implement to just analyze the entire
G>> solution the first time and then only analyze the changed classes
G>> one by one?
G>>
G>> Gabriel
G>>


0
Comment actions Permalink

Hello Gabriel Lozano-Morán,

Could you please give some examples of really important guidelines, which
a) Is not detected by compiler
b) Is detected by Resharper
c) Cannot be batch-processed using "reformat code" on solution/project/folder
with required checkboxes turned on?

I can name only one: redundant local variable assignments and initializations.


Sincerely,
Ilya Ryzhenkov


G> Hello Ilya,
G>
G> It is important if you work with a large team and have guidelines
G> everybody should follow.
G>
G> Gabriel Lozano-Morán
G> MCSD .NET
G> Real Software
G> http://www.realsoftware.be
G> http://www.realdn.net
>> Hello Gabriel Lozano-Mor�n,
>>
>> Why just not build solution and have compiler report any errors or
>> warnings? I understand, that there are some warnings that are
>> detected by Resharper and not detected by compiler, like redundand
>> casts, etc. But is it so important to clean them up, until you open a
>> file?
>>
>> Sincerely,
>> Ilya Ryzhenkov
G>>> Then how about an option to only show the errors / warnings after a
G>>> build? Wouldn't it be easy to implement to just analyze the entire
G>>> solution the first time and then only analyze the changed classes
G>>> one by one?
G>>>
G>>> Gabriel
G>>>


0
Comment actions Permalink

Actually, a very old (and now defunct) Java IDE ("Kawa") did it years and
years ago. It's actually something I think should be an "expected" feature
in any new IDE. It is very nice and very handy to be able to look at the
state of your solution "at a glance".

I hope it's a planned feature of the full Resharper IDE you guys have
planned, even if it's never something that makes it into the VS Resharper
Plug-In.


"Dmitry Shaporenkov (JetBrains)" <dsha@jetbrains.com> wrote in message
news:c8a894d9feada8c7fd37d80d7018@news.intellij.net...

Hello Gabriel,

>

an efficient implementation of solution-wide analysis is involved in any
case. This is something we
may consider for future versions, especially in view of products on the
market (OmniCore, in particular)
that claim to do that.

>

Regards,
Dmitry Shaporenkov
JetBrains, Inc
http://www.jetbrains.com
"Develop with pleasure!"

>
>> Then how about an option to only show the errors / warnings after a
>> build? Wouldn't it be easy to implement to just analyze the entire
>> solution the first time and then only analyze the changed classes one
>> by one?
>>
>> Gabriel
>>
>> "Eugene Pasynkov (JetBrains)" <Eugene.Pasynkov@jetbrains.com> wrote in
>> message news:dsho20$cm7$1@is.intellij.net...
>>
>>> It is rather easy to implement this feature.........
>>> But the only REAL problem that we can't incrementally reanalyze
>>> solution,
>>> so every change will mean full solution re-analysis.
>>> --
>>> Eugene Pasynkov
>>> Developer
>>> JetBrains, Inc
>>> http://www.jetbrains.com
>>> "Develop with pleasure!"
>>> "Paul Bradshaw" <pbradshaw@advsol.com> wrote in message
>>> news:dsgda6$k61$1@is.intellij.net...
>>>> This is an often-requested feature, but it won't be in 2.0.
>>>> Hopefully they'll find some way to implement it (even as an option)
>>>> in some version of 2.x -- ideally some red/yellow/green indicator
>>>> for each *.cs file in the solution exporer, and an over-all
>>>> red/yellow/green indicator for each project node in the solution
>>>> explorer. But I don't know how much control they can have with
>>>> that. Even if they have to code their own equivalent solution
>>>> explorer window, it'd be worth it to get that "birds-eye-view" of
>>>> the status of your entire solution, rather than having to open each
>>>> file...
>>>>
>>>> "Gabriel Lozano-Morán" <gabriel@no-spam.org> wrote in message
>>>> news:dsg9nm$uj3$1@is.intellij.net...
>>>>
>>>>> I guess the subject sayz it all. Is there a way to view all the
>>>>> errors and warning of all the classes in a solution. It would be
>>>>> nice to have them all in the task list.
>>>>>
>>>>> Cheers
>>>>>
>>>>> Gabriel Lozano-Morán
>>>>> MCSD .NET
>>>>> Real Software
>>>>> http://www.realsoftware.be
>>>>> http://www.realdn.net
>



0
Comment actions Permalink

Hello Ilya,

We mainly use FxCop for guidelines but if ReSharpers also shows warnings
them why not use those warnings?

I am talking about:
a) redundant casts
b) empty constructors
c) not accessed local variables
d) unused local variables
e) redundant using directives
f) unused private members
g) unaccessed private fields
h) redundant new modifier
i) redundant boolean comparison
j) redundant this qualifiers
k) ...

Gabriel Lozano-Morán
MCSD .NET
Real Software
http://www.realsoftware.be
http://www.realdn.net

Hello Gabriel Lozano-Morán,

Could you please give some examples of really important guidelines,
which
a) Is not detected by compiler
b) Is detected by Resharper
c) Cannot be batch-processed using "reformat code" on
solution/project/folder
with required checkboxes turned on?
I can name only one: redundant local variable assignments and
initializations.

Sincerely,
Ilya Ryzhenkov

G>> Hello Ilya,
G>>
G>> It is important if you work with a large team and have guidelines
G>> everybody should follow.
G>>
G>> Gabriel Lozano-Morán
G>> MCSD .NET
G>> Real Software
G>> http://www.realsoftware.be
G>> http://www.realdn.net
>>> Hello Gabriel Lozano-Mor�n,
>>>
>>> Why just not build solution and have compiler report any errors or
>>> warnings? I understand, that there are some warnings that are
>>> detected by Resharper and not detected by compiler, like redundand
>>> casts, etc. But is it so important to clean them up, until you open
>>> a file?
>>>
>>> Sincerely,
>>> Ilya Ryzhenkov
G>>>> Then how about an option to only show the errors / warnings after
G>>>> a build? Wouldn't it be easy to implement to just analyze the
G>>>> entire solution the first time and then only analyze the changed
G>>>> classes one by one?
G>>>>
G>>>> Gabriel
G>>>>


0
Comment actions Permalink

Hello Gabriel Lozano-Morán,

G> We mainly use FxCop for guidelines but if ReSharpers also shows
G> warnings them why not use those warnings?
G>
G> I am talking about:
G> a) redundant casts
- removed by batch reformat

G> b) empty constructors

    • not batch processed


G> c) not accessed local variables
- detected by compiler

G> d) unused local variables
- detected by compiler

G> e) redundant using directives
- removed by batch reformat

G> f) unused private members

    • not batch processed


G> g) unaccessed private fields
- detected by compiler

G> h) redundant new modifier
- detected by compiler

G> i) redundant boolean comparison

    • not batch processed


G> j) redundant this qualifiers
- removed by batch reformat

So we have few cases left:

  • empty constructors

It is not important at all, because it does not influence anything. On the
other hand, it can be placeholder for future code.
For example, Resharper shows this as redundant ctor, which is wrong IMHO:
public Country()
{
// TODO: make it setup default currency
}
This ctor has side effect. Comment is displayed in VS tasks window.

  • redundant boolean comparison

It's somewhat more important, because requirement to have no code like "if
(SomeIdentifier == true)" suggests better names, so they look like "if (Required)".
On the other hand Resharper doesn't suggest changing "if (Required == false)"
to "if (!Required)". So in its current state it is half-baked solution.

  • unused private members

Fields are processed by compiler. We have methods, properties and nested
classes that are not checked in a batch. This is the only important thing
I can see, because it can "hold" other members (including fields) which are
not used, but claimed to be used. On the other hand, Resharper could analyse
it deeper, it's not that complex.

Note: Why I'm trying to discuss it to the exact point? Because I recently
did batch analysis in my Nerpa plugin. It is EXTREMELY usefull, but it analyses
code in slightly different manner than Resharper does. And same things are
not analysed by compiler at all. So I want to understand, if I may need to
collect Resharper's errors/warnings too. Or may be JetBrains will do it themselves.

Sincerely,
Ilya Ryzhenkov


0
Comment actions Permalink

Hello Ilya,

So what your basically trying to say is to remove the warnings/error highlighting
in ReSharper? I am surprised that you actually put so much energy in responding
to my feature request because as I understand it, this has been requested
by more people.

Anyway not everybody "batch reformats" and its true that lot of these warnings
are detected by the compiler but I still stand with my point on why not show
warnings and errors solution-wide.

Gabriel Lozano-Morán
MCSD .NET
Real Software
http://www.realsoftware.be
http://www.realdn.net

Hello Gabriel Lozano-Morán,

G>> We mainly use FxCop for guidelines but if ReSharpers also shows
G>> warnings them why not use those warnings?
G>>
G>> I am talking about:
G>> a) redundant casts

- removed by batch reformat

G>> b) empty constructors
G>>

    • not batch processed

G>> c) not accessed local variables
G>>

- detected by compiler

G>> d) unused local variables
G>>

- detected by compiler

G>> e) redundant using directives
G>>

- removed by batch reformat

G>> f) unused private members
G>>

    • not batch processed

G>> g) unaccessed private fields
G>>

- detected by compiler

G>> h) redundant new modifier
G>>

- detected by compiler

G>> i) redundant boolean comparison
G>>

    • not batch processed

G>> j) redundant this qualifiers
G>>

- removed by batch reformat

So we have few cases left:

  • empty constructors

It is not important at all, because it does not influence anything. On
the
other hand, it can be placeholder for future code.
For example, Resharper shows this as redundant ctor, which is wrong
IMHO:
public Country()
{
// TODO: make it setup default currency
}
This ctor has side effect. Comment is displayed in VS tasks window.

  • redundant boolean comparison

It's somewhat more important, because requirement to have no code like
"if
(SomeIdentifier == true)" suggests better names, so they look like "if
(Required)".
On the other hand Resharper doesn't suggest changing "if (Required ==
false)"
to "if (!Required)". So in its current state it is half-baked
solution.

  • unused private members

Fields are processed by compiler. We have methods, properties and
nested
classes that are not checked in a batch. This is the only important
thing
I can see, because it can "hold" other members (including fields)
which are
not used, but claimed to be used. On the other hand, Resharper could
analyse
it deeper, it's not that complex.
Note: Why I'm trying to discuss it to the exact point? Because I
recently did batch analysis in my Nerpa plugin. It is EXTREMELY
usefull, but it analyses code in slightly different manner than
Resharper does. And same things are not analysed by compiler at all.
So I want to understand, if I may need to collect Resharper's
errors/warnings too. Or may be JetBrains will do it themselves.

Sincerely,
Ilya Ryzhenkov



0
Comment actions Permalink

Hello Gabriel Lozano-Morán,

No, you got me wrong. There are several things I want to be discussed and
understood:
1. It is not good time for Resharper team to add major features. Otherwise
we will wait for release forever.
2. There are other ways to achieve most of the things you are asking for.
3. There are some other people outside of JetBrains (e.g. me) that can help
with this, but I need to understand the reason. Check Nerpa batch analysis
for example.
4. If you enforce code style on the daily basis, you mostly will not have
any non-green code in the solution. If you don't enforce it, but sometimes
want to go and clean this - you need batch processing of course.

Solution wide analysis is much more complex, then batch processing. The reason
of complexity is that it is when you change code in one file, it generates
error or warning in another file. During batch processing, the code does
not change and you just go file by file and collect any highlights. The drawback
is that after you did any change, result can become invalid.

Sincerely,
Ilya Ryzhenkov


0
Comment actions Permalink

Hello Ilya,

I don't want this as a new feature in version 2.0 because I am as eagered
as other people for the ReSharper RTM version. The problem is that if you
work for big multinationals you simply can't use any software you want. I
hope you understand the number of signatures you need just to be able to
use ReSharper to develop software for controlled environments. Using then
an add-in for ReSharper requires again a numberous number of signatures again.

I will fully support the NERPA plugin and I might even more support it if
it can be used for custom check-in policies for Team Foundation Server :)
hint

By the way, the latest NERPA builds are very unstable on VS2K3 unfortunately
I had to uninstall it.

Gabriel Lozano-Morán
MCSD .NET
Real Software
http://www.realsoftware.be
http://www.realdn.net

Hello Gabriel Lozano-Morán,

No, you got me wrong. There are several things I want to be discussed
and
understood:
1. It is not good time for Resharper team to add major features.
Otherwise
we will wait for release forever.
2. There are other ways to achieve most of the things you are asking
for.
3. There are some other people outside of JetBrains (e.g. me) that can
help
with this, but I need to understand the reason. Check Nerpa batch
analysis
for example.
4. If you enforce code style on the daily basis, you mostly will not
have
any non-green code in the solution. If you don't enforce it, but
sometimes
want to go and clean this - you need batch processing of course.
Solution wide analysis is much more complex, then batch processing.
The reason of complexity is that it is when you change code in one
file, it generates error or warning in another file. During batch
processing, the code does not change and you just go file by file and
collect any highlights. The drawback is that after you did any change,
result can become invalid.

Sincerely,
Ilya Ryzhenkov



0
Comment actions Permalink

I don't think anyone is requesting this feature for the 2.0 release.

It would, however, be nice if it were considered for some future 2.x release
... and certainly for any stand-alone IDE being developed.


"Ilya Ryzhenkov" <orangy@netix.ru> wrote in message
news:5992f43b11fd7c8c7ff94452bd8d7@news.jetbrains.com...

Hello Gabriel Lozano-Morán,

>

No, you got me wrong. There are several things I want to be discussed and
understood:
1. It is not good time for Resharper team to add major features. Otherwise
we will wait for release forever.
2. There are other ways to achieve most of the things you are asking for.
3. There are some other people outside of JetBrains (e.g. me) that can
help with this, but I need to understand the reason. Check Nerpa batch
analysis for example.
4. If you enforce code style on the daily basis, you mostly will not have
any non-green code in the solution. If you don't enforce it, but sometimes
want to go and clean this - you need batch processing of course.
Solution wide analysis is much more complex, then batch processing. The
reason of complexity is that it is when you change code in one file, it
generates error or warning in another file. During batch processing, the
code does not change and you just go file by file and collect any
highlights. The drawback is that after you did any change, result can
become invalid.

>

Sincerely,
Ilya Ryzhenkov

>




0
Comment actions Permalink

Hello Paul,

Well, just curious, did anyone try to use JustCode! (http://www.omnicore.com/justcode.htm)
and tell how solution-wide analysis works there?

Sincerely,
Ilya Ryzhenkov


0
Comment actions Permalink

I've tried.
Solution-wide analysis looks like to work fine, but the latest build has a
lot of problems with generics (It found 260 errors in our solution).
And their analysis is very simple - they do not detect a lot of problems

--
Eugene Pasynkov
Developer
JetBrains, Inc
http://www.jetbrains.com
"Develop with pleasure!"
"Ilya Ryzhenkov" <orangy@netix.ru> wrote in message
news:5992f43b11fe1a8c8005c65294b4b@news.jetbrains.com...

Hello Paul,

>

Well, just curious, did anyone try to use JustCode!
(http://www.omnicore.com/justcode.htm) and tell how solution-wide analysis
works there?

>

Sincerely,
Ilya Ryzhenkov

>



0
Comment actions Permalink

I can imagine the tradeoff between usability (e.g. response time) and the
requirement to analyze the entire solution after each change, especially
given that a small change in one class can have deep repercussions
throughout the code base. The really mystifying issue is that I would find
such a feature most useful for those large solutions that consist of 10 or
more projects containing hundreds of classes. In other words, it would be
most useful on exactly the projects that cause the most pain with regards to
a full analysis after every change.

I see your point and I certainly would not want to wait more than a second
after making a code change, and I wouldn't want to wait after each build
either. I say this because I prefer to keep a tight change/build/unit test
cycle going and a full analysis after each build would likely significantly
hinder productivity. Perhaps a tradeoff could be reached by providing an
option in a context menu. Say right click on a solution to analyze the
entire solution or right click on a project to analyze the project. It's
just a thought.

"Eugene Pasynkov (JetBrains)" <Eugene.Pasynkov@jetbrains.com> wrote in
message news:dsho20$cm7$1@is.intellij.net...

It is rather easy to implement this feature.........
But the only REAL problem that we can't incrementally reanalyze solution,
so every change will mean full solution re-analysis.

>

--
Eugene Pasynkov
Developer
JetBrains, Inc
http://www.jetbrains.com
"Develop with pleasure!"
"Paul Bradshaw" <pbradshaw@advsol.com> wrote in message
news:dsgda6$k61$1@is.intellij.net...

>> This is an often-requested feature, but it won't be in 2.0. Hopefully
>> they'll find some way to implement it (even as an option) in some version
>> of 2.x -- ideally some red/yellow/green indicator for each *.cs file in
>> the solution exporer, and an over-all red/yellow/green indicator for each
>> project node in the solution explorer. But I don't know how much control
>> they can have with that. Even if they have to code their own equivalent
>> solution explorer window, it'd be worth it to get that "birds-eye-view"
>> of the status of your entire solution, rather than having to open each
>> file...
>>
>>
>> "Gabriel Lozano-Morán" <gabriel@no-spam.org> wrote in message
>> news:dsg9nm$uj3$1@is.intellij.net...
>>>I guess the subject sayz it all. Is there a way to view all the errors
>>>and warning of all the classes in a solution. It would be nice to have
>>>them all in the task list.
>>>
>>> Cheers
>>>
>>> Gabriel Lozano-Morán
>>> MCSD .NET
>>> Real Software
>>> http://www.realsoftware.be
>>> http://www.realdn.net
>>>
>>
>>
>



0
Comment actions Permalink

The issue I run into primarily is with significantly large solutions that
contain say a hundred or classes. It's not so easy to open each class one by
one looking for a class that's not green. It would be significantly faster
to scroll through the project list to discover if any projects have warnings
and then drill down through the folders and classes to discover which
classes have warnings. On the other hand, I wouldn't want such a feature to
hinder my modify/build/test cycle either.


"Ilya Ryzhenkov" <orangy@netix.ru> wrote in message
news:5992f43b11fc198c7fd4c2b80554d@news.jetbrains.com...

Hello Gabriel Lozano-Morán,

>

Why just not build solution and have compiler report any errors or
warnings? I understand, that there are some warnings that are detected by
Resharper and not detected by compiler, like redundand casts, etc. But is
it so important to clean them up, until you open a file?

>

Sincerely,
Ilya Ryzhenkov

>
>

G> Then how about an option to only show the errors / warnings after a
G> build? Wouldn't it be easy to implement to just analyze the entire
G> solution the first time and then only analyze the changed classes one
G> by one?
G> G> Gabriel

>



0
Comment actions Permalink

Or rather, just have a background processing thread running at low priority
doing the updating and analysis. I'm fine with waiting to be notified of
issues in far-off source files. And the state could be saved when a
solution is closed, so it has a set state when it opens up again, and then
goes through and updates/refreshes on a background thread. As long as any
source file I have open in the editor window is more or less instantly
analyzed, that's cool.

There could also be a manually invoked command to refresh/update the entire
source file thing at a high priority, so it wouldn't kick in when you don't
want it. That way you could make a change that potentially affects other
files, hit the key, and see if it did. Of course, if you use refactorings
properly, this shouldn't ever be an issue.

Most of the time I want this feature is when I'm picking up new code I
haven't worked on before, or when I'm working with existing code with new
versions of reshaper that "find more stuff", so I can go through and quickly
see where the problem areas are. Once I get things green, they tend to stay
green, and the feature is less important (and the "manual invokation" is
more reasonable).


"Lothan" <lothan@newsguy.com> wrote in message
news:dthgsg$ogu$1@is.intellij.net...
>I can imagine the tradeoff between usability (e.g. response time) and the
>requirement to analyze the entire solution after each change, especially
>given that a small change in one class can have deep repercussions
>throughout the code base. The really mystifying issue is that I would find
>such a feature most useful for those large solutions that consist of 10 or
>more projects containing hundreds of classes. In other words, it would be
>most useful on exactly the projects that cause the most pain with regards
>to a full analysis after every change.
>

I see your point and I certainly would not want to wait more than a second
after making a code change, and I wouldn't want to wait after each build
either. I say this because I prefer to keep a tight change/build/unit test
cycle going and a full analysis after each build would likely
significantly hinder productivity. Perhaps a tradeoff could be reached by
providing an option in a context menu. Say right click on a solution to
analyze the entire solution or right click on a project to analyze the
project. It's just a thought.

>

"Eugene Pasynkov (JetBrains)" <Eugene.Pasynkov@jetbrains.com> wrote in
message news:dsho20$cm7$1@is.intellij.net...

>> It is rather easy to implement this feature.........
>> But the only REAL problem that we can't incrementally reanalyze solution,
>> so every change will mean full solution re-analysis.
>>
>> --
>> Eugene Pasynkov
>> Developer
>> JetBrains, Inc
>> http://www.jetbrains.com
>> "Develop with pleasure!"
>> "Paul Bradshaw" <pbradshaw@advsol.com> wrote in message
>> news:dsgda6$k61$1@is.intellij.net...
>>> This is an often-requested feature, but it won't be in 2.0. Hopefully
>>> they'll find some way to implement it (even as an option) in some
>>> version of 2.x -- ideally some red/yellow/green indicator for each *.cs
>>> file in the solution exporer, and an over-all red/yellow/green indicator
>>> for each project node in the solution explorer. But I don't know how
>>> much control they can have with that. Even if they have to code their
>>> own equivalent solution explorer window, it'd be worth it to get that
>>> "birds-eye-view" of the status of your entire solution, rather than
>>> having to open each file...
>>>
>>>
>>> "Gabriel Lozano-Morán" <gabriel@no-spam.org> wrote in message
>>> news:dsg9nm$uj3$1@is.intellij.net...
>>>>I guess the subject sayz it all. Is there a way to view all the errors
>>>>and warning of all the classes in a solution. It would be nice to have
>>>>them all in the task list.
>>>>
>>>> Cheers
>>>>
>>>> Gabriel Lozano-Morán
>>>> MCSD .NET
>>>> Real Software
>>>> http://www.realsoftware.be
>>>> http://www.realdn.net
>>>>
>>>
>>>
>>
>>
>



0

Please sign in to leave a comment.