// A skeleton of a C# program 
using System;
namespace YourNamespace
{
  class YourClass
  {
  }

  struct YourStruct
  {
  }

  interface IYourInterface 
  {
  }

  delegate int YourDelegate();

  enum YourEnum 
  {
  }

  namespace YourNestedNamespace
  {
    struct YourStruct 
    {
    }
  }

  class YourMainClass
  {
    static void Main(string[] args) 
    {
      //Your program starts here...
    }
  }
}

var currentPerformanceCounterCategory = new System.Diagnostics.
  PerformanceCounterCategory();

if ((val1 > val2) && (val1 > val3))
{
  // Take appropriate action.
}

// The following declaration creates a query. It does not run
// the query.

var phrase = "lalalalalalalalalalalalalalalalalalalalalalalalalalalalalala";
var manyPhrases = new StringBuilder();
for (var i = 0; i < 10000; i++)
{
  manyPhrases.Append(phrase);
}
//Console.WriteLine("tra" + manyPhrases);

// When the type of a variable is clear from the context, use var 
// in the declaration.
var var1 = "This is clearly a string.";
var var2 = 27;
var var3 = Convert.ToInt32(Console.ReadLine());

// When the type of a variable is not clear from the context, use an
// explicit type.
int var4 = ExampleClass.ResultSoFar();

// Naming the following variable inputInt is misleading. 
// It is a string.
var inputInt = Console.ReadLine();
Console.WriteLine(inputInt);

var syllable = "ha";
var laugh = "";
for (var i = 0; i < 10; i++)
{
  laugh += syllable;
  Console.WriteLine(laugh);
}

foreach (var ch in laugh)
{
  if (ch == 'h')
    Console.Write("H");
  else
    Console.Write(ch);
}
Console.WriteLine();

// Preferred syntax. Note that you cannot use var here instead of string[].
string[] vowels1 = { "a", "e", "i", "o", "u" };


// If you use explicit instantiation, you can use var.
var vowels2 = new string[] { "a", "e", "i", "o", "u" };

// If you specify an array size, you must initialize the elements one at a time.
var vowels3 = new string[5];
vowels3[0] = "a";
vowels3[1] = "e";
// And so on.

 // First, in class Program, define the delegate type and a method that 
// has a matching signature.

// Define the type.
public delegate void Del(string message);

// Define a method that has a matching signature.
public static void DelMethod(string str)
{
  Console.WriteLine("DelMethod argument: {0}", str);
}


 // In the Main method, create an instance of Del.

// Preferred: Create an instance of Del by using condensed syntax.
Del exampleDel2 = DelMethod;

// The following declaration uses the full syntax.
Del exampleDel1 = new Del(DelMethod);

static string GetValueFromArray(string[] array, int index)
{
  try
  {
    return array[index];
  }
  catch (System.IndexOutOfRangeException ex)
  {
    Console.WriteLine("Index is out of range: {0}", index);
    throw;
  }
}

// This try-finally statement only calls Dispose in the finally block.
Font font1 = new Font("Arial", 10.0f);
try
{
  byte charset = font1.GdiCharSet;
}
finally
{
  if (font1 != null)
  {
    ((IDisposable)font1).Dispose();
  }
}


// You can do the same thing with a using statement.
using (Font font2 = new Font("Arial", 10.0f))
{
  byte charset = font2.GdiCharSet;
}

Console.Write("Enter a dividend: ");
var dividend = Convert.ToInt32(Console.ReadLine());

Console.Write("Enter a divisor: ");
var divisor = Convert.ToInt32(Console.ReadLine());

// If the divisor is 0, the second clause in the following condition
// causes a run-time error. The && operator short circuits when the
// first expression is false. That is, it does not evaluate the
// second expression. The & operator evaluates both, and causes 
// a run-time error when divisor is 0.
if ((divisor != 0) && (dividend / divisor > 0))
{
  Console.WriteLine("Quotient: {0}", dividend / divisor);
}
else
{
  Console.WriteLine("Attempted division by 0 ends up here.");
}

var instance1 = new ExampleClass();

ExampleClass instance2 = new ExampleClass();

// Object initializer.
var instance3 = new ExampleClass { Name = "Desktop", ID = 37414, 
  Location = "Redmond", Age = 2.3 };

// Default constructor and assignment statements.
var instance4 = new ExampleClass();
instance4.Name = "Desktop";
instance4.ID = 37414;
instance4.Location = "Redmond";
instance4.Age = 2.3;

 public Form2()
{
  // You can use a lambda expression to define an event handler.
  this.Click += (s, e) =>
    {
      MessageBox.Show(
        ((MouseEventArgs)e).Location.ToString());
    };
}


 // Using a lambda expression shortens the following traditional definition.
public Form1()
{
  this.Click += new EventHandler(Form1_Click);
}

void Form1_Click(object sender, EventArgs e)
{
  MessageBox.Show(((MouseEventArgs)e).Location.ToString());
}

var seattleCustomers = from cust in customers
            where cust.City == "Seattle"
            select cust.Name;

var localDistributors =
  from customer in customers
  join distributor in distributors on customer.City equals distributor.City
  select new { Customer = customer, Distributor = distributor };

var localDistributors2 =
  from cust in customers
  join dist in distributors on cust.City equals dist.City
  select new { CustomerName = cust.Name, DistributorID = dist.ID };

var seattleCustomers = from cust in customers
            where cust.City == "Seattle"
            select cust.Name;

var seattleCustomers2 = from cust in customers
            where cust.City == "Seattle"
            orderby cust.Name
            select cust;

// Use a compound from to access the inner sequence within each element.
var scoreQuery = from student in students
         from score in student.Scores
         where score > 90
         select new { Last = student.LastName, score };