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

I don't know how to write this suggestions clearer than the current title. I'll try to explain the background of this suggestions
This is the current situations in VS 2012:
1. F# has included as one of first class language since VS 2010
2. F# user base has grown larger than before, thanks to #1, Microsoft! But unfortunately? (read next)
3. Can't create ASP.NET project template using F# other than C# or VB.
4. Can't create WPF (hence Silverlight) project visually using F# (again, other than using C# or VB)
5. Can't create visual Windows Store app using F#, just like #4.
6. Other IDE such as Eclipse has provided great support and also open architecture using open plugin when dealing with Visual Designer on IDE. Therefore any language running on Eclipse can directly add visual designer support on Eclipse, not just Java and C++. It's also easier to create another visual design support for Eclipse for other programming language.
7. Xamarin has provide us F# support to create ASP.NET project and it has proven that F# is not just for numerical analysis and data centric (e.g. type provider) anymore. This will make VS 2012 less appealing to code F# on ASP.NET directly.
8. If there is other language runs on Visual Studio included as part of VS project templates, there's a large possibility it won't have visual design support other than C# or VB. Even C++ in Visual Studio can't be used to create ASP.NET and WPF projects, for example.

Based on those situations, I propose:
1. Make VIsual Studio's visual designers to be extensible and open enough (it doesn't have to be open source) to be available for other programming language to use. I know this will require large rewrite of current VS visual designer, but this closed and exclusive architecture (closed that it's only available on C# and VB) will provide less productivity when using other languages.
2. In accordance to #1 above, there should be open architecture (can be in form of open API) to simply add visual designer if there;s only small languages at initial releases for the next release of Visual Studio.

A sample use case of # 2 is: if there's VS 2015, the Visual designer support may only be available for C# and VB but the Visual designer can be available to be customized and then further repackaged as complete custom project template with visual designer supports for other language such as F# and can be other languages be another G# or Z# (or whatever) as well as long as it runs on top of .NET CLR.

The term visual designer I mentioned here includes current visual designers we have in VS 2012: ASP.NET Webform, ASP.NET MVC, WPF, Silverlight, Windows Phone, Windows Store.

We know the issue about solution folders not being real windows folders. Not saying we change that, but, just as any project has a "Show all files" button in solution explorer, let's have a similar button active for the solution itself.

It'd still show any folders not mapping to projects or solution folder as "not included" (like in projects when you have other files you need to right click and "include" them in project).

An enhancement might be also being able to create equivalent solution folders (as in: the "include" feature), but just accessing the solution windows explorer folder from solution explorer will be enough really.

It's a bit long but very easy to understand.
The following block statements would have members as well as the objects:
If
Select
While
Do
For
For Each
Try

First of all, some simple examples...
- the Exit and the Continue block-member-statements:
For i = 0 To 99
    Select Case i
        Case x
            For.Exit
        Case y
            For.Continue
    End Select
Next

- an example to control the outer For loop:
For i = 0 To 99
    For j = 0 To 99
        Select Case j
            Case a
                Select.For.For.Exit
            Case b
                Select.For.For.Continue
        End Select
    Next
Next

- same with short qualification:
For i = 0 To 99
    For j = 0 To 99
        Select Case j
            Case a
                For.For.Exit
            Case b
                For.For.Continue
        End Select
    Next
Next

------------------------------------------------

BLOCK MEMBERS:

- members of the For and For Each block objects:
For.<ParentBlock>
For.Exit
For.Continue
For.From (read-only)   //not available in For Each block
For.To   (read-only)   //not available in For Each block
For.Step (read-only)   //not available in For Each block
For.IsFirstIteration
For.IsLastIteration
For.Finish.Exited      (enumerator -1)
For.Finish.Skipped     (enumerator 0)
For.Finish.Completed   (enumerator 1)

- members of the Do and While block objects:
Do.<ParentBlock>
Do.Exit
Do.Continue
Do.IsFirstIteration

- members of the Try-Catch block object:
Try.<ParentBlock>
Try.Exit       (may not be important)
Try.Let
Try.CurrentException
Try.Result.IsNoException
Try.Result.IsLocalException
Try.Result.IsForwardedException

- members of the If-Else block object:
If.<ParentBlock>
If.Let

- members of the Select-Case block object:
Select.<ParentBlock>
Select.Exit
Select.Let
Select.Is (read-only reference of the test expression)
Select.FallThrough    (may not be important)
 
------------------------------------------------------ 
 
Other simple examples:
- an example to determine the finishing of a (functional) For loop:
Select For i = j To k
           If i = 100 Then
               Exit For
           End If
       Next
    Case For.Finish.Completed, For.Finish.Exited
        MessageBox.Show("There was iteration.")
    Case For.Finish.Skipped
        MessageBox.Show("There was no iteration.")
End Select
 
 
- simplified Try block with exception typelist after the Catch keyword:
Try
    PossibleException()
Catch ExceptionA, ExceptionB, ExceptionC
    MessageBox.Show(Try.CurrentException.Message)
Catch Else ' new explicit statement
    MessageBox.Show(Try.CurrentException.Message)
Finally
    If Try.Result.IsNoException Then
        MessageBox.Show("There was no exception.")
    End If
End Try
 
 
- assignment with the Let statements:
sNumber = Select Case(i) As String
              Case 1
                  Let "one"
              Case 2
                  Let "two"
              Case 3
                  Let "three"
              Case Else
                  Let "other"
          End Select
 
 
- assignment in a nested block:
myNumber = If(bln1) As Integer
               If bln2 Then
                   If.If.Let 1
               Else
                   If.If.Let 2
               End If
           Else
               Let 3
           End If
 
 
- an example to control the second (middle) For loop:
For i = 0 To 99
    For j = 0 To 99
        For k = 0 To 99
            Select Case k
                Case x
                    For.For.Exit
                Case y
                    For.For.Continue
            End Select
        Next
    Next
Next
 
 
- an other example with the to leave the outermost For loop:
For i = 0 To 99
    If b Then
        For j = 0 To 99
            Select j
                Case x
                    For.If.For.Exit
            End Select
        Next
    End If
Next
 
 
Advantages:
- in some cases would not need extra conditional structures with extra variables to control the flow in nested blocks, so some algorithm would run faster
- in some cases the GoTo jump-statement would be replaced when it is used to accelerate the run-time to leave nested blocks
- shorter and simplified code
- safer algorithm planning
- easier and safer maintenance
- easier code reading
- easy learning and using (block members by intelisense)
- reusable block feature (Let statement) like the lambda functions
- faster development
- there is no new reserved keyword
- etc...

In addition:
- it can be adaptable to C# also
- in C# the
  switch.break,
  do.break,
  for.break,
  while.break,
  statements would allow a safer and more sophisticated coding then with the general break statement

This idea is for corporate TFS not for cloud based:
There some probles when I want to attach huge dumpfiles to Bug in TFS. Now it is not possible becouse some of them more than 2GB.
BTW attach 2GB to WTI causes DB to grow extremly and It is a problem with backup and maintain.

So I want to suggest following feature:
I can limit size of attachment which will be stored within DB (ie 4MB).
I can attach a network storage and make redirection of greater files to be stored in this network storage automatically: within TFS only link will be stored.

This also allows to manage backup ploitics differently for them.