Eclipse vs. Visual Studio


While this topic seems to be oranges to apples comparison from the first glance, if you try to think about this, you’ll notice that this comparison is not so stupid as it seems from the beginning. Both Eclipse and Visual Studio are large, mature IDEs, both support many languages, both have very active community, both are mostly oriented towards devlopment for one of the two largest development platforms in the world: Java and .NET respectively. This last item brings another similarity: Java and .NET are very similar platforms by themselves by loads of factors, Java and C# are very similar languages that borrowed features from each other during all their history. So to some extent it is actually possible to compare Eclipse and Visual Studio, if they are used for very similar purposes.

For me as Java developer it was always tempting to draw back the curtains and look to the other world to see, what people do there, compared to what is done in my world.¬†From time to time, while reading the Web, I notice some articles and forum topics that try to compare Eclipse and Visual Studio. What bugs me the most is that it is always taken for granted that Visual Studio is hands down full-blown IDE with thousands of features included out of the box, while Eclipse is poor man’s experience that has not so much included, but sometimes you can even find some plugins and have functionality similar to Visual Studio. One day I decided to make a comparison of the features of both IDEs. Because I know Eclipse quite good, but have no experience with Visual Studio, I’ve taken all the information from the public docs. For Eclipse I was using and for Visual Studio I’ve taken everything from MSDN. The comparison appeared quite lengthy. At the end I collected some other users’ experience with the two IDEs. If anything is incorrect in this article, I’m open to hear and correct all the mistakes. So let’s go.



Extract Method Refactoring (C#)
Rename Refactoring (C#)
Encapsulate Field Refactoring (C#)
Extract Interface Refactoring (C#)
Remove Parameters Refactoring (C#)
Reorder Parameters Refactoring (C#)


Change Method Signature
Extract Method
Extract Local Variable
Extract Constant
Convert Anonymous Class to Nested
Move Type to New File
Convert Local Variable to Field
Extract Superclass
Extract Interface
Use Supertype Where Possible
Push Down
Pull Up
Extract Class
Introduce Parameter Object
Introduce Indirection
Introduce Factory
Introduce Parameter
Encapsulate Field
Generalize Declared Type
Infer Generic Type Arguments
Migrate JAR File
Create Script
Apply Script

Code Formatting

VS: CTRL-A to select all text then do the CTRL+K-F combo


Run/Debug Configuration

VS: ONE Run Configuration and ONE Debug Configuration

Eclipse: any number of run and debug configurations

Source Code Actions


Surround-with Code Snippets
Add using
Generate From Usage
Hook Up Events By Using IntelliSense (C#)
Implement Abstract Base Class
Implement Interface
IntelliSense for Override


Toggle Comment
Add Block Comment
Remove Block Comment
Generate Element Comment
Shift Right
Shift Left
Correct Indentation
Format Element
Add Import
Organize Imports
Sort Members
Clean Up
Override/Implement Methods
Generate Getter and Setter
Generate Delegate Methods
Generate hashCode() and equals()
Generate toString()
Generate Constructor using Fields
Add Constructor from Superclass
Surround With
Externalize Strings
Find Broken Externalized Strings




Type Hierarchy



Organize Imports


Eclipse: CTRL+SHIFT+O,


Import order list
New Static…
Number of imports needed for .*
Number of static imports needed for .*
Do not create imports for types starting with a lower case letter

Save Actions


not available, only via hack,


Local History



Quick Access


Eclipse: CTRL+3




Content Assist / Code Completion


Show completion list after a character is typed
Place keywords in completion lists
Place code snippets in completion lists
Committed by typing the following characters
Committed by pressing the space bar
Add new line on enter at end of fully typed word
Pre-selects most recently used member


Content Assist

Completion inserts/Completion overwrites
Insert single proposals automatically
Insert common prefixes automatically
Add import instead of qualified name
Use static imports
Fill method arguments and show guessed arguments
Insert parameter names
Insert best guessed arguments
Configure Type Filters.
Sort proposals
Show camel case matches
Hide proposals not visible in the invocation context
Hide deprecated references
Enable auto activation
Auto activation delay
Auto activation triggers for Java
Auto activation triggers for Javadoc
Select the proposal kinds contained in the ‘default’ content assist list
Content assist cycling
Timeout for fetching a parameter name from attached Javadoc

Quick Fix

Add missing package declaration or correct package declaration
Move compilation unit to package that corresponds to the package declaration
Remove unused, unresolvable or non-visible import
Invoke ‘Organize imports’ on problems in imports
Create new class, interface, enum, annotation or type variable for references to types that can not be resolved
Change visibility for types that are accessed but not visible
Rename to a similar type for references to types that can not be resolved
Add import statement for types that can not be resolved but exist in the project
Add explicit import statement for ambiguous type references (two import-on-demands for the same type)
If the type name is not matching with the compilation unit name either rename the type or rename the compilation unit
Remove unused private types
Add missing type annotation attributes
Create new constructor for references to constructors that can not be resolved (this, super or new class creation)
Reorder, add or remove arguments for constructor references that mismatch parameters
Change method with constructor name to constructor (remove return type)
Change visibility for constructors that are accessed but not visible
Remove unused private constructor
Create constructor when super call of the implicit default constructor is undefined, not visible or throws an exception
If type contains unimplemented methods, change type modifier to ‘abstract’ or add the method to implement
Create new method for references to methods that can not be resolved
Rename to a similar method for references to methods that can not be resolved
Reorder or remove arguments for method references that mismatch parameters
Correct access (visibility, static) of referenced methods
Remove unused private methods
Correct return type for methods that have a missing return type or where the return type does not match the return statement
Add return statement if missing
For non-abstract methods with no body change to ‘abstract’ or add body
For an abstract method in a non-abstract type remove abstract modifier of the method or make type abstract
For an abstract/native method with body remove the abstract or native modifier or remove body
Change method access to ‘static’ if method is invoked inside a constructor invocation (super, this)
Change method access to default access to avoid emulated method access
Add ‘synchronized’ modifier
Override hashCode()
Open the ‘Generate hashCode() and equals()’ wizard
Correct access (visibility, static) of referenced fields
Create new fields, parameters, local variables or constants for references to variables that can not be resolved
Rename to a variable with similar name for references that can not be resolved
Remove unused private fields
Correct non-static access of static fields
Add ‘final’ modifier to local variables accessed in outer types
Change field access to default access to avoid emulated method access
Change local variable type to fix a type mismatch
Initialize a variable that has not been initialized
Create getter and setters for invisible or unused fields
Remove unneeded catch block
Remove unneeded exceptions from a multi-catch clause (1.7 or higher)
Handle uncaught exception by surrounding with try/catch or adding catch block to a surrounding try block
Handle uncaught exceptions by surrounding with try/multi-catch or adding exceptions to existing catch clause (1.7 or higher)
Handle uncaught exception by adding a throw declaration to the parent method or by generalize an existing throw declaration
Add a missing JAR or library for an unresolvable type
Open the build path dialog for access restriction problems or missing binary classes.
Change project compliance and JRE to 1.5
Change workspace compliance and JRE to 1.5
Add cast or change cast to fix type mismatches
Let a type implement an interface to fix type mismatches
Add type arguments to raw references
Complete switch statements over enums
Remove dead code
Insert ‘//$FALL-THROUGH$’
Insert null check
For non-NLS strings open the NLS wizard or mark as non-NLS
Add missing @Override, @Deprecated annotations
Add missing Javadoc comments
Add missing Javadoc tags
Suppress a warning using @SuppressWarnings
Throw the allocated object
Return the allocated object
Add @SafeVarargs annotation for heap pollution warnings (1.7 or higher)
Remove invalid @SafeVarargs annotations (1.7 or higher)
Remove redundant type arguments (1.7 or higher)
Add inferred type arguments (1.5 and 1.6)

Quick Assist

Inverse if statement
Inverse boolean expression
Invert local variable
Invert equals
Inverse conditional expression
Pull negation up
Push negation down
Remove extra parentheses
Put expression in parentheses
Put expressions in parentheses
Join nested if statements
Swap nested if statements
Split if statement with and’ed expression
Join selected ‘if’ statements with ||
Join ‘if’ sequence in if-else-if
Split if statement with or’d expression
If-else assignment to conditional expression
If-else return to conditional expression
Conditional expression assignment to If-else
Conditional expression return to If-else
Switch to If-else
Add missing case statements on enums
Exchange operands
Cast and assign
Use separate catch blocks
Move exceptions to separate catch blocks
Combine catch blocks
Add finally block
Add else block
Replace statement with block
Unwrap blocks
Pick out string
Convert string concatenation to StringBuilder (J2SE 5.0) or StringBuffer
Convert string concatenation to MessageFormat
Split variable
Join variable
Assign to variable
Extract to local
Assign parameter to field
Array initializer to Array creation
Convert to ‘enhanced for loop’ (J2SE 5.0)
Convert to indexed ‘for’ loop (J2SE 5.0)
Convert to Iterator-based ‘for’ loop (J2SE 5.0)
Create method in super class
Rename in file
Rename in workspace
Extract to local variable
Extract to constant
Extract method
Inline local variable
Convert local variable to field
Convert anonymous to nested class
Replace with getter and setter (Encapsulate Field)
Insert inferred type arguments

What Other People Say

Quote #1

The author is missing next features in VS:

  1. Quick Fix – Assign to local variable. Write the RHS of an assignment statement, then Ctrl+1 to have the IDE suggest/insert a LHS.
  2. Curly brace auto-completion. When I type the opening brace and hit enter, automatically indent one tab and add a close brace on the following line.
  3. Ctrl-Click for type definition hyperlinking. Basically, a mouse gesture for Visual Studio’s Go To Definition F12. I’ve been told there is an extension for this??
  4. Ctrl-Click for externalized strings (resources in .NET?). In Eclipse, when I Ctrl-Click on an externalized message referenced as a static String, I can jump to the properties file directly.
  5. “Flexible” Go To Definition. In Eclipse, if I write some code that calls a method, and I don’t have the particular overload parameters sequenced correctly, I can still (typically) jump to the definition of one of the overloads. Since they’re typically clustered together in the target type, this is a poor man’s way of getting around reading the Javadoc.
  6. (Speaking of Javadoc), Hover over a method to see its NDoc documentation. Reading the commented XML syntax on a method doesn’t do it for me.
  7. Link With Editor / Show In. When I’m jumping around using Go To Definition, I quickly lose track of where (in the resource tree) a particular class is. In Eclipse, I can toggle and untoggle Link With Editor to highlight the resource in Package Explorer. How do I select the current editor’s file in Solution Explorer?
  8. Synchronize View. This one is a HUGE hole. How the hell do you .NET people sync your code in a sane way??
  9. Multi-Page Editors. I’ll qualify this one a bit by saying that I’ve seen the implementation details of multi-page editors in Eclipse, and there are some definite issues. But the functionality is critical when you have an XML document which also has a graphical editor. (Entity Framework conceptual models, I’m lookin’ at you.) Gimme a synchronized two-tab editor so I don’t have to keep doing Open With, closing the other editor (can’t have both open at the same time, another FAIL), etc.
  10. Outline View in the XML editor. ‘Nuff said.
  11. Collapse All / Expand All. Solution Explorer needs these badly.
  12. File -> Restart. After I install a Visual Studio Extension, I need to restart. Please make this one click, thanks.
  13. Workspaces. I really don’t know how to explain this one. You can see one of my complaints (relating to Team Explorer) in this post. Another example is that of “recent solutions”. Please just keep my last solution open? What am I missing here? I need to have separate “threads” of work that are preserved somehow, so I can easily switch between conceptual projects in my daily work.

Quote #2

Some excerpts:

1) Eclipse Quick Access is an amazing usability feature, in my opinion.

Short version:

Imagine a QuickSilver or Launchy inside the IDE!.

With Quick Access you can navigate to almost any part of the IDE using the keyboard. Yes, that can be done in Visual Studio also but you need to learn the shortcut to each view: Ctrl+Alt+J to go to the Object Browser; Ctrl+Alt+L for Solution Explorer, etc; or use generic window switching shortcuts (like Ctrl+F6 to go to next window one by one).

In Eclipse, you only need one shortcut: Ctrl+3 to open the Quick Access tool.

The Quick Access tool hat allows you to just start typing the name of any command, view, perspective, menu even source files! and it will auto-complete and suggest alternatives.

Quick Access:

Will remember abbreviations and your most frequent accessed items and progressively adapt to the way you use it.
Will also allow you type PascalCase abbreviations: You want to go to the Data Source Explorer view? type DSE and it will show up as the first option.
It will also show the keyboard shortcut for each item as a learning aid.

2) Missing from VS:

Ctrl+click on a method name to go its definition;
Auto brace complete (for C#) – but, to be honest, sometimes is annoying;

3) Notice how Visual Studio remembers the layout of the IDE (open windows, positions, etc) that you used the last time the debugger was running? And how it switches between that and the “non debugging” IDE layout automatically.

Eclipse does the same with Perspectives. Only that you can fully customize them not only for debugging and not debugging, but you can create several layout with different IDE configurations and switch between them with a simple click.

Want to go to the debugging layout while not debugging?. Just click the on the Debugging Perspective toolbar button.

Want to invent a new layout with no editors and only the Package Explorer and the Javadoc view are visible? Move your windows as you want and save it as a new perspective.

It is a great way of switching your IDE appropriately when your mind is also switching from one kind of task to another.

4) I assume you refer to the out-of-the-box Eclipse vs. out-of-the-box VS (otherwise, there are always plugins that add extra features).

Missing from VS:

Ctrl+click on a method name to go its definition;
Auto brace complete (for C#) – but, to be honest, sometimes is annoying


From what I’ve found so far, there is no feeling that Eclipse lacks any features compared to VS. Furthermore, seems that Visual Studio sucks at every single point of comparison. Visual Studio looks like a dumb text editor compared to Eclipse. So called “Intellisense” that is supposed to be the most intelligent code completion utility, in reality is just a children’s toy compared to what Eclipse has built in. If after that you still think that Visual Studio is superior in terms of features… Well… Maybe I missed anything. Just tell me I was wrong.

Now the question is: how in the hell is it possible that one of the largest corporations in the world with so much money cannot even come close to free open source product that is developed by community? Does it mean Microsoft just CAN’T do more? Even if it had unlimited money and resources? Does it mean that Microsoft just doesn’t care, if the cashflow goes on anyway?