It would be nice to add a notion of sunrise (year, quarter ?) in ObsoleteAttribute and add a project build option:

[X] No obsolete warning for sunrise in more than [.......] years/quarters.

ObsoleteAttributes defined without a sunrize will continue to fire a warning (but we can imagine an exclusion list).

We can also imagine to add the notion of excluded modules/assemblies/classes in ObsoleteAttribute: Declaring a class or member obsolete will fire warnings when compiling the assembly that implements them. Firing warning on a code that offers backward compatibility is near a non-sens (in that case we should applause more than warn).

On each release of a library it will be possible to adjust obsolescence to a more realistic/user acceptable sunrise. This will encourage the users to migrate to more modern constructs giving them the time to upgrade (and allowing them to choose the right time in their plans to do obsolescence management).

And last but not least, it would be nice to have an explanationUrl member in ObsoleteAttribute allowing the user to go directly from the warning to a web page explaining the reasons for obsolescence, the non obsolete alternative constructs ...

I suggest that you make it easier for web applications to trigger ClickOnce applications on local machines. I am well aware of the potential security risks inherent in this suggestion but we need to do this and it has been a hassle finding basic information on how to trigger ClickOnce apps and pass parameters. This aspect of ClickOnce needs to be better documented and supported.

(Also given a web app running on one server and ClickOnce published to another, there is apparently no way at all to trigger the ClickOnce app from a web app if the ClickOnce server is unavailable.)

Access controls by "Sparse" Index - Even a Custom control with Index can not be accessed as: MyControl(x).Text or MyControl(x).Value

This was one of 2 major issues preventing me from porting VB 6 apps to .NET. The only implementation possible would require superfluous loops through the controls multiple times to mimic the behavior but at cost of performance. It wouldn't matter if the controls load in order, it only matters that I can access them in a specific order and that the index value can correspond to an object array indexed as well.

I had built a Wizard that built all my stored procs, all the forms, and the controls with all supporting code that was generic. 90% of a new application could be built in 5 minutes. In fact, with two steps, all I had to do was change the startup object and encrypt the server credentials in the registry, and the application was ready to run. Some customizations needed for longer forms, but, most were astheticly pleasing as is. I can not find a way to duplicate this since .Net came out. i.e.:

Using an array populated from getrows()

For x = 0 to ubound(oTables, 2)
Next 'x

Yet, access data and controls from the same loop.

Sample of controls:

lblData(0).Caption 'Maybe ID
txtData(1).Text 'Maybe FirstName
cmbData(2).Text 'Maybe EyeColor
chkData(3).Value 'Maybe Male/Female

Then I had a generic "SaveFormData" that was called to check if data had changed and call stored procedure to update or insert etc. depending on the state. Also a generic LoadFormData which would load data initially and at any time a change had occurred to which a refresh was required. All of this was packed nicely into a Wizard that would optionally build the procs for you in the database.

I'm considering learning Python because at least it doesn't punish it's loyal users. I had been purchasing MS Products religiously, but, I'm starting to see value in Open Source as I don't have to pay a fortune to get screwed. I stayed inside the box, not using 3rd party controls, wrote my own report engine, print preview, Windowing via SetParent since MDI wouldn't let me do what was needed, but, still inside the box.

If I've missed the boat somewhere, and you can help me get some of this functionality, you can reach me at ctruett3@hotmail.com

In the library topic "How to: Synchronize a Producer and a Consumer Thread (C# and Visual Basic)" (http://msdn.microsoft.com/en-us/library/yy12yx1f.aspx), the SyncEvents class keeps an array of its new item and exit thread events and provides this array to consumers to facilitate using those events in a WaitHandle.WaitAny(WaitHandle[]) call.

As implemented, some ConsumerA could assign a value to the array that is not one of the events being used in the current SyncEvents instance. If some ConsumerB then tries to wait on the array, its behavior will be undefined at best (if an unrelated WaitHandle has been assigned) or it will receive an ArgumentNullException at worst. In a debugging scenario, the cause of these problems may very well be non-obvious.

The SyncEvents.EventArray property and its backing field should be removed in favor of a method that returns a new array for each caller. This way, all callers will get references to the correct SyncEvents.NewItemEvent and SyncEvents.ExitThreadEvent in the arrays that they receive, and no one caller can interfere with the wait behavior of the others by modifying its own copy of the array.

There are only a limited number of events open. Paint is not one of them. I am developing/extending an analytics platform. My idea was to add a map under my charts and use different WMS services. The problem is that to draw on top of it would mean drawing on top of the web control... which is not possible. The analytics platform is extensible enough and allows to add 3rd party controls like webControl. So, the hicup is in your control. I cannot add another WMS layer because it would be static and I would loose the functionality of the analytics tool.

Dear Microsoft:

Thank you very much for all the effort you have been puttin into providing the development community with great tools. I have been using Visual Studio and team foundation service and I love it. It has changed the way I do things. There is still something missing. I work with a group of Open Source entusiasts. Most of them have mac computers. As a matter of fact, I still have not worked with any interface designer that does not own a Mac. I keep trying to make them move to .Net. Azure and TF service are great incentives but they still do not make the move because the interface developers cannot edit razor pages on their Macs. If you could build a tool for these HTML 5 experts to edit razor I would finally be able to make them move to .Net allowing me to finally step out of writting PHP scripts.

It's a best practice to explicitly handle assumptions as shown below:

public void DoSomething(MyObj withMyObj)
{
if(withMyObj == null)
return;

... do something
}

OR

public void DoSomething(MyObj withMyObj)
{
Debug.Assert(withMyObj != null)

... do something
}

A few simple attributes could make the code more terse and help keep the method focused. Hey, we could even generate several unit tests based on this feature. This is the markup I have in mind:

[ArgAssumption("withMyObj", ArgumentValue.IsNull, WhenTrue.Return)]
public void DoSomething(MyObj withMyObj)
{

... do something
}

[ArgAssumption("message", ArgumentValue.IsNull, WhenTrue.Return)]
[ArgAssumption("message", ArgumentValue.IsEqualTo, "", WhenTrue.Return)]
public void ThrowException(string message)
{
throw new Exception(message);
}

This would be helpful for many simple validations. That is most common with my code. A method has a few simple validations such as null checks and then carries on with its business.

Return types could be limited to primitive types. Such as [ArgAssumption("someArg", ArgumentValue.IsEqualTo, "", WhenTrue.Return, false)]
public bool SomeFunc(string someArg){...}.

Another option which would be nice is the option to throw an exception rather than return a value.