*** Visual Studio 2012 absolutely needs to have an integrated .Net obfuscation feature that works on Windows Store and Windows Phone Store apps & games. ***

The Dotfuscator tool that's integrated into Visual Studio 2012 cannot be used to obfuscate Windows Store or Windows Phone Store apps, making it fairly useless to "modern app" developers who are targeting Windows 8, Windows RT, and/or Windows Phone 8.

On April 30, 2013, PreEmptive (the vendor of Dotfuscator) expired the license of the free (and separately downloadable) "Dotfuscator for Windows Phone 7" tool. PreEmptive now charges $500/year or $150/quarter to use another version of Dotfuscator that will work with Windows Store and Windows Phone Store apps, adding a big expense to obfuscate mobile/modern apps - and that is out of reach for most Indie devs & Student devs.

It is disappointing to see Microsoft's previous deal with PreEmptive (to provide a free version of Dotfuscator for Windows Phone apps & games) come to an end, and without proposing alternative solutions with developer-friendly licensing. Regardless of whether it is PreEmptive's or some other vendor's obfuscator, Microsoft should be helping developers protect their code by providing obfuscation on all Microsoft target operating systems.

At the very least, if this is not economically feasible for Visual Studio Express, developers with Visual Studio Professional (or higher) should expect .Net obfuscation as part of the standard integrated tools.

The new natvis framework brings some improvements over autoexp.dat but sadly some key features from autoexp.dat have been lost, making it ****** and in some cases impossible to visualise types in natvis that could easily be visualised using autoexp.dat.

1. The loss of the $c notation means that it is no longer possible to reference the container object when defining the next pointer in a linked list. It is therefore not possible to correctly visualise a linked list that is teminated with an 'end node' held by the container because its address is not accessible at the point where it needs to be compared (please see http://social.msdn.microsoft.com/Forums/en-US/vsdebug/thread/1b7c2caa-e3d4-41f8-9611-a1ab0a2ca301).

2. It is also no longer possible to display the items in a collection as part of the display string because natvis does not support adding a list of items to a display string as autoexp.dat used to.

3. There is no equivalent in natvis to the <,t> notation from autoexp.dat that displayed the most derived type name for the current type.

new method modifier 'keyword' enable new features: avoiding (), coma and point when call function

for example:

first, declaration

class SQLSyntax{

public int? keyword between(this int firstNumber, int nextNumber)
{
if(firstNumber>nextNumber)
return firstNumber;
else return null;
}
public bool keyword and(this int? firstNumber, int lastNumber){

if(firstNumber!=null && firstNumber<lastNumber) return true;
else return false;

}
}

usage:

//....do something

if (10 bewteen 5 and 11) //do something
else //do something

istead of

//....do something

if (10.bewteen(5).and( 11) ) //do something
else //do something

NOTE: if we use keyword params or a lot normal parameter we can avoid coma and use only space for split params (or not it can be under discussion)

Pros:
- simplyfy code
- special hilighting in IDE (as keyword)
- determinability (when we use keyword 'keyword' we cannot use (), coma or point when call method)

cons
- determinability isnt flexibility

Since .NET 4.0, C# and VB allow covariant/contravariant events. However, if I do something like

public interface IObservableStuff<out T> {
event Action<T> Happened;
}

and implement that event using the default implementation by simply declaring it with the line

public event Action<T> Happened;

then this implementation uses the Delegate.Combine method to add a handler to the event. Unfortunately, if the object was typed using string as T, the interface would allow to also chain a delegate typed as Action<object>, which is fine as a string also is an object. However, the Delegate.Combine operation throws an exception. A simple workarround to this behaviour is to create a custom event that inserts a wrapping lambda expression, however, this cannot be removed.

public event Action<T> Happened {
add {
_Happened += input => value(input);
}
remove {
throw new NotSupportedException();
}
}

So please allow Delegate.Combine and Delegate.Remove to respect covariance and contravariance on methods, which can be easily implemented by changing the type check from equality to IsAssignableFrom. Note that the only issue where this means more computational effort is the exception case where the exception clearly dominates the effort for IsAssignableFrom.

With the global shift towards mobile and touch computing, it is so sad that the Microsoft leadership is still sleeping during this historic time in computing. Visual Studio 12 has just been released with the same dated controls/toolbox from the last PC era!!!

We need new touch friendly control and forms ASAP that create a great user experience. We are not living in the 1990s anymore and mobile touch computing is the future. Wouldn't it be nice to have the tools and controls to go with it????

Your answer might be metro apps - still can't figure out how to write one. But even Apple iOS uses touch friendly controls and forms for RAD - rapid app development. And so should you too!!!

Currently when we file a bug, can there is prefilled templates per user based. For example 90% of the bugst hat are filed are always to one same Area path or a sub path of the same. Also the iteration that i have is the current month. I could get a prefilled template with teh default priority of 2 for me and so that whenever I have to file a bug , I just need to fill in the necessary details.

Also , it could get he build number using some custom process that i could define like an exe running on the box or a shared file with the latest build number.