C# on the left, Java on the right:

//C#:
var person = new Person(); 
//variable person is of type Person, obviosly
 
//Java
Person person = new Person(); //variable type must be expressed explicitelly 

var people = new[]
{
   new Person { FirstName = "Daniel", LastName = "Turan" },
   new Person { FirstName = "John", LastName = "Smith" }, 
   new Person { FirstName = "John", LastName = "Brown" }
}

var me = people .Where(p => p.FirstName == "Daniel").First();
 
var numberOfJohns = people.Count(p => p.FirstName == "John");
 
var mostFrequestNames = people
   .GroupBy(p => p.FirstName)
   .OrderByDescenting(group => group.Count())
   .Select(group => new
   {
      Name = group.Key,
      Occurences = group.Count()
   });

References :

• C# has decimal fixed point.
• C# has var (local variable type inference) since 3.0.
• C# has real generics ("reified generics") since 2.0. Java has fake generics ("erasure generics") since Java 5.
• C# has real properties.
• C# has value types.
• C# has attributes since the very beginning. Java only has annotations (the Java equivalent to attributes) since Java 5.
• Ditto for for-each loops.
• Ditto for auto-boxing and auto-unboxing.
• Ditto for varargs.
• C# has using (and the dispose pattern, via IDisposable) since the very beginning. Java only has try-with-resources (the Java equivalent to using) since Java 7.
• Ditto for string switches. Also note that C# switches are more versatile than Java's ones; you can use goto case and goto default to jump to other cases.
• C# has lambdas since 3.0, long before Java did (Java 8).
• Ditto for extension methods. (The closest thing Java has to extension methods are interface default methods, and those are introduced in Java 8.)
• C# has static classes (non-instantiable classes where all methods have to be static) since 2.0. In Java, you can hack around it by making a class with only private constructors, but you can still define non-static methods in such a class.
• C# methods are non-virtual by default. In Java you can only make a method non-virtual by making it private or final.
• C# requires using override when overriding, and forbids using override when not overriding. This makes it easier to detect when a refactor is breaking other code.
• C# has operator overloading.
• C# has compile-time constants using const. In Java, you can only have compile-time constants for numbers, booleans, characters, and strings.
• C# does not have checked exceptions. Many programmers consider checked exceptions a broken concept.
• C# has named and optional arguments since 4.0.
• C# has ref and out parameters. In Java, everything is pass-by-value; it's not possible to have pass-by-reference.
• C# has enumerator generators via yield since 2.0.

• Covariant and contravariant generic type parameters have been around since Java 5, but were introduced in C# 4.0.
• Java enumerations (which are full-fledged classes) are much more advanced than C# enumerations (which are basically just integers). For example, you can use it to implement a simple state machine.
• Java has BigDecimal which provides decimal floating point, as opposed to C#'s builtin decimal fixed point.

• If you are developing applications for Windows desktops, or for Windows servers (e.g. ASPdotNET), or for Windows phone, then C#.
• If you are developing a PC game or writing an OS, then C or C++.
• If you are writing server applications (e.g. web or mobile), or targeting Android phones, then Java.
• If you are targeting iPhones/iPads, then ObjectiveC or Swift.
• If you are building the browser side of an application, or if using node.js, then Javascript.
• Since the comments I keep getting are pointing out how non-universal my original answer to this silly question was, I should point out that there are many other computer languages that are great for various uses. Python, PHP, Perl, Ruby, assembly, whatever.

The Evolution of the C# Language

Writing Quality Code with C#: Common Gotchas

The Future of C#

References :

EDIT

Reduce page weight

Minimize the number of files

Reduce domain lookups

Cache reused content

1. HTTP Conditional Get for RSS Hackers
2. HTTP 304: Not Modified
3. HTTP ETag on Wikipedia
4. Caching in HTTP
5. Learn HTML

Optimally order the components of the page

Reduce the number of inline scripts

Use modern CSS and valid markup

Chunk your content

<TABLE>
  <TABLE>
    <TABLE>
          ...
    </TABLE>
  </TABLE>
</TABLE>

<TABLE>...</TABLE>
<TABLE>...</TABLE>
<TABLE>...</TABLE>

Minify and compress SVG assets

Specify sizes for images and tables

table-layout: fixed;

Choose your user-agent requirements wisely