Return to Answer

A couple of things I like:

-If you create an interface similar to

 public interface SomeObject<T> where T : SomeObject<T>, new() 

you force anything that inherits from this interface to contain a parameterless constructor. It is very useful for a couple of things I've run across.

-Using anonymous types to create a useful object on the fly:

var myAwesomeObject = new {Name="Foo", Size=10}; 

-Finally, many Java developers are familiar with syntax like:

public synchronized void MySynchronizedMethod(){} 

However, in C# this is not valid syntax. The workaround is a method header:

 [MethodImpl(MethodImplOptions.Synchronized)] public void MySynchronizedMethod(){} 

A couple of things I like:

-If you create an interface similar to

 public interface SomeObject<T> where T : SomeObject<T>, new() 

you force anything that inherits from this interface to contain a parameterless constructor. It is very useful for a couple of things I've run across.

-Using anonymous types to create a useful object on the fly:

var myAwesomeObject = new {Name="Foo", Size=10}; 

-Finally, many Java developers are familiar with syntax like:

public synchronized void MySynchronizedMethod(){} 

However, in C# this is not valid syntax. The workaround is a method attribute:

 [MethodImpl(MethodImplOptions.Synchronized)] public void MySynchronizedMethod(){} 

A couple things I like:

-If you create an interface similar to:

 public interface SomeObject<T> where T : SomeObject<T>, new() 

you force anything that inherits from this interface to contain a parameterless constructor... very useful for a couple things I've run across.

-Using anonymous types to create a useful object on the fly

var myAwesomeObject = new {Name="Foo", Size=10}; 

-Finally, many Java developers are familiar with syntax like

public synchronized void MySynchronizedMethod(){} 

however, in C# this is not valid syntax. The workaround is a method header:

 [MethodImpl(MethodImplOptions.Synchronized)] public void MySynchronizedMethod(){} 

A couple of things I like:

-If you create an interface similar to

 public interface SomeObject<T> where T : SomeObject<T>, new() 

you force anything that inherits from this interface to contain a parameterless constructor. It is very useful for a couple of things I've run across.

-Using anonymous types to create a useful object on the fly:

var myAwesomeObject = new {Name="Foo", Size=10}; 

-Finally, many Java developers are familiar with syntax like:

public synchronized void MySynchronizedMethod(){} 

However, in C# this is not valid syntax. The workaround is a method header:

 [MethodImpl(MethodImplOptions.Synchronized)] public void MySynchronizedMethod(){} 

A couple things I like:

-If you create an interface similar to:

 public interface SomeObject<T> where T : SomeObject<T>, new() 

you force anything that inherits from this interface to contain a parameterless constructor... very useful for a couple things I've run across.

-Using anonymous types to create a useful object on the fly

var myAwesomeObject = new {Name="Foo", Size=10}; 

-Finally, many java developers are familiar with syntax like

public synchronized void MySynchronizedMethod(){} 

however, in c# this is not valid syntax. The workaround is a method header:

 [MethodImpl(MethodImplOptions.Synchronized)] public void MySynchronizedMethod(){} 

A couple things I like:

-If you create an interface similar to:

 public interface SomeObject<T> where T : SomeObject<T>, new() 

you force anything that inherits from this interface to contain a parameterless constructor... very useful for a couple things I've run across.

-Using anonymous types to create a useful object on the fly

var myAwesomeObject = new {Name="Foo", Size=10}; 

-Finally, many Java developers are familiar with syntax like

public synchronized void MySynchronizedMethod(){} 

however, in C# this is not valid syntax. The workaround is a method header:

 [MethodImpl(MethodImplOptions.Synchronized)] public void MySynchronizedMethod(){}