One of the features that was dropped from VB9 was dynamic interfaces:
http://download.microsoft.com/download/5/8/4/5841bc1a-e864-4423-bb75-d4f3c18c0af5/visual%20basic%209.0%20overview.doc

Any chance of bringing this back? I know it can be done at runtime:
http://www.codeproject.com/Articles/16074/DuckTyping-Runtime-Dynamic-Interface-Implementatio

But that looses the compile time type checking, which is the great advantage of dynamic interfaces -- it gives you the best of both worlds, you can define a set of behavior for an existing class without having to have control over that class, based upon it's public interface, with no chance of it failing because of a missing property or method (if the class doesn't meet the requirements for the interface, compilation fails).

Many other languages have 'strong' typing. Java, C#, and VB have strong typing regarding classes, but not for the primitive numeric types. It can be a great aid to making large-scale industrial and commercial software. For example, if one could declare two different types Apples and Oranges:

Type Apples Is New Integer
Type Oranges Is New Integer
...
Dim A As Apples = 3
Dim B As Oranges = 4

then accidentally mixing arithmetic or assignment between these types would be prevented by the compiler, e.g. the assignment:

A = B

would be rejected by the compiler (and Intellisense) as an error.

If such mixing were really required, it would be done by an explicit conversion, e.g.:

A = DirectCast(B, Apples)

would succeed.

It would also be extremely useful to be able to add a range restriction, e.g.:

Type DecimalDigit Is New Integer Range 0 to 9
Dim D As DecimalDigit

If we accidentally attempt to assign an invalid value to D, e.g.:

D = 11

this would be caught, either dynamically (throwing an exception) or statically if possible.

It would also be useful to be able to declare a new named type in terms of another generic type fully or partially instantiated, e.g.:

Type NameList Is New List(Of String)
Dim N As New NameList
N.Add("John Smith")

Partial instantiation would be by means of a variable representing one (or more) of the generic parameters, e.g.:

Type PersonAge Is New Integer Range 0 To 140
Type NameDict(Of T) Is New Dictionary(Of String, T)
Dim D As New NameDict(PersonAge)
D.Add("John Smith",98)

These extra facilities would be fully compatible with existing VB code.

Just a very simple thing:

I had an attribute and a field written on two lines like this:

<DebuggerBrowsable(DebuggerBrowsableState.Never)> _
Private _SomeField As String

and wanted to add a line comment after the '_':

...State.Never)> _ 'My reason why

I now get the following error: "Line continuation character '_' must be preceded by at least one white space and must be the last character on the line."

My request now is to change the rule "...must be the last character on the line" to "...must be the last non-white-space character on that part of the line that does not belong to a line comment."

Or, in other words, to allow line comments after a '_' line continuation.

Best regards
Chris

I have to repeat the begging for comments within multiline statements in visual basic... yes, I know you refused to do that for me and numerous others over the last 6-7 years stating that it is "by design"... so what? our continuous and numerous complaints just show that this request has its roots, so do not make excuses of design... *change that design detail* and everything will be ok... mr. hejlsberg on /BUILD/ conference talks about 'paste as c#' and 'paste as vb.net' and you are not able to convince yourself of the need to change that tiny design glitch... no, please do not explain to me that procedure arguments can be better described by xml comments... I know that, but I am asking you for this comments because of all the other multiline statements... also, do not say that there is no need for multiline statements, for you even (almost) removed the need to put underline at the end of continued statemens... so, it is high time to stop excuses. change the design. implement. show the vb.net community that they do not have to be ashamed in front of others because of that silly detail. thnx.

Add the option of single instance application (program.. IDK) in VB.Net with WCF and .Net 4.0.
We need to make single instance applications while using VB.net, too, not just VB!
Example of program which needs it:

C4D-Alpha: A launcher program which enables and launches some features on a specific program (external).
C4D-Alpha saves the settings for next launch on every change.
C4D-Alpha's best use is assigning it to a keyboard shortcut (ie. CTRL ALT SHIFT C) and then when its up (after a quarter of a second) press the corresponding key for the feature you want to launch.

Link: http://www.mediafire.com/download.php?lz58m1zqaiidnfy

I needed to make the program disappear after each feature launch cause there isn't any easy way to make single instance application with VB.Net.

I'm very happy that Microsoft is committed to VB.NET have the same features as C#.
One feature I use extensivle in C# is collection initializers. I've just noticed that VB.NET supports these but not for read-only class properties.
I found at http://msdn.microsoft.com/en-us/library/dd293617.aspx that if a collection has a an Add method, it is used to initialize the variable. This should also apply to read-only collection properties.

Here is compilable C# code showing the feature working:

using System;
using System.Collections.Generic;

namespace ConsoleApplication3
{
class Class1
{
private readonly List<Int32> list = new List<Int32>();

public List<Int32> ListProp
{
get
{
return this.list;
}
}
}

class Program
{
static void Main(string[] args)
{
// a collection initialization
var list = new List<Int32> { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

// a read-only collection property initialization
var class1 = new Class1
{
ListProp = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }
};
}
}
}

Thanks,
Antao

Often, if i write a line of code, i start to write something and think this would be better split in more lines and use a new variable

Basic example:

result = (a + b) * c

while writing the line, i think (a+b) is rather complex in one line, so just use a new temporary variable. But first I complete this line, if I already had defined this variable and write the "Dim" and the assignment afterwards.

so, i write:

result = x * c

and afterwards i go some lines up and start to write

dim x as...

After writing "Dim " it would be great, if intellisense would suggest all undefined variables from the local scope. (in real life, the variable name would of course be longer then "x")

Hi,
I am a good programmer of VB.Net I found it Very Easy to use. But the thing i want is that programmer should be able to extend language by building new keywords. As In some class If we use IDisposable Then we can use Using statement for that class. So I want that user make new classes and make new keywords for them. Although It is easy to say this but i think its programming will be so hard but VB.Net will be language extending itself. There should be a class for implement or inheriting Keyword and build rules to use that keyword