Extend enums with a methods, primary with conversion.
Example of definition:

public enum DoorState
{
Open,
Closed,
Semi-closed;

public static implicit operator DoorState(string param)
{
return (DoorState) Enum.Parse(typeof(DoorState), param);
}
}

Examples of use:

door1.State = "Closed"; // DoorState.Closed
dish.Status = "ReadyForEating"; //DishState.Ready
usercontrol1.Visilibity = false; //Visilibity.Hidden
service.Status = "Stopped" //ServiceStatus.StopWithHandlers

I think it's not nice to have 10+ private variables being the backend of any property that has a NotifyPropertyChanged() event.

A new keyword such as "property" can be used to substitute the private variable.

Observe:

Before:
private int a;
public int A { get { return a; } set { a = value; NotifyProperty("A"); } }

After:

public int A { get { return property; } set { property = value; NotifyProperty("A"); } }

Saves a lot of space no?

I would like to see C# support using field-targeted attributes on auto-properties where the compiler applies said attribute to the generated backing field. This functionality has precedent in that the compiler already behaves like this for such attributes applied towards events:

// This works in all versions of C#
[field: NonSerialized]
public event EventHandler SomeEvent;

// This will not compile
[field: NonSerialized]
public string SomeProperty { get; set; }

// This seems unnecessary
[NonSerialized]
private string _someOtherProperty;
public string SomeOtherProperty {
get { return _someOtherProperty; }
set { _someOtherProperty = value; }
}

Create supporting auto notify properties, like this:

public string Data { get; set; notify; }
public string ID
{
get;
set;
notify: { ... }
}

LINQ query syntax lacks a lot of features that exist in extension method syntax, such as .Single(), .First(), .Distinct(), .Average(), ...

I.e.:

var col =
from cust in customers
where cust.ID == 5
select first cust;

Develop a class to Run a query from sql Script File Directly in to TempDb (SqlCeClient)

Ex : Run a Query from a file "payslip.sp" into local database .

Currently I have to instruct people to un-comment a #define directive if they also have another set of files in their project. This should be automatic.
As discussed here: http://stackoverflow.com/questions/7656001/detecting-if-a-class-type-is-defined-prior-to-compiling

For example:
#ifType SomeType
SomeType.DoSomething();
#else
DefaultWay.DoSomething();

for example:
class A{
string member;
class B{
void M(){
owner.member="***";
}
}
}

I would like to see the sealed modifer being used to seal a base-class in the context of its sub-class

public abstract class MyFrameWorkUserControl : sealed UserControl

I want the users of my framework user control to follow the coding-guidelines in MyFrameworkUserControl's protected virtual or abstract methods/properties/events and not override anything in UserControl.

Properties/events/Methods in UserControl will not be sealed for MyFrameworkUserControl, but it wll be sealed for those who inherits from MyFrameworkUserControl.

I could manually seal every UserControl method and/or property in MyFrameworkUserControl, but the proposed construct would make things easier.

Java programming language having a look and feel property for swings like the same i want to use look and feel properties in c# form that we can give new look and feel to our application on each time.

Support nullable types in attributes

I find it tedious to have to define a "var result = new List<T>" every time I want to write a function that returns an IList<T>. It would be nice to be able to do something like "return append <value>" and never have to define the list variable.

Extend the DLR with a dynamic<T> type. This would let you specify the type that members would be, but leave what members exist as dynamic. It would allow compile time checks on everything except member names and would be very useful if you had something like a Dictionary<string,Guid> as you're member names would match against the string, but the compiler would know you were returning a Guid.

Provide the option to break on a custom condition. For example if you have a loop that executes code a certain amount of times and seems to be failing on the 10th loop only, then set the break point to break at the 10th loop as opposed to having it break on the first. This would save alot of time in programs where exceptions are being thrown with in loops.

Add a shorthand operator to the C# compiler for Lazy<T> similar to Nullable<T>.

Back In .NET 2.0, Nullable<T> was given the shorthand operator ? to be able to declare a nullable variable. This makes it easier to read than the generic version:

Nullable<int> customerId;
vs
int? customerId;

The Lazy<T> class in .NET 4 is great; however, the declaration of variables starts to loose readability:

Lazy<BindingList<string>> customerNames;
Lazy<int> customerId
vs something like
BindingList<string>~ customerNames;
int~ customerId;

C# can be incorporated a new Scripting language.
No need to have CLR. Just all the syntax.
This will help all the developers to use same syntax for server side and browser side scripting. To be a scripting language, one important feature is required, that is all objects should be dynamic.

OOPS & branching and looping, delegates all are very much required for us to create a robust browser coding.

Why don't we have a feature called 'Extension properties' in C#? I have seen this feature in other managed languages like F#. Is CLR team is already working on this or no plans yet?

Say you have isDirty field and a IsDirty property on a form

bool isDirty = false;
bool IsDirty
{
get { return isDirty; }
set
{
this.commandBarButtonSave.Enabled = value;
isDirty = value;
}
}

Nothing prevents a developer from assigning the field, and then not setting the button state, even though the only way it is ment to be accessed is through the property.

Something like the code below would be nice

bool IsDirty
{
get;
set
{
this.commandBarButtonSave.Enabled = value;
impl = value;
}
}

impl would then be a key word accessing the actual field