Прочитав посты из блога soumya, решил написать заметку по языку C#.
Каждые 2-3 года выходит новая версия .NET. В каждой версии придумывают новые технологии (WPF) и улучшают старые (WinForms, ASP.NET). Изменения эти значительны и требуют много времени на изучение. Синтаксис же языка C# меняется несильно.
Обычно пишут списком: что появилось в C# 2.0, 3.0 и т.д. Чтобы не копипастить материал с других сайтов, я сгруппирую его по языковым конструкциям. Примеры максимально простые, многие детали языка опущены.
Буду писать C# 1.0, при этом подразумевать реализацию этого языка в Visual Studio .NET 2003 (C# 2.0 – VS 2005, C# 3.0 - VS 2008, C# 4.0 - VS 2010).
Переменная
Именованная величина, которая может принимать различные значения.
Объявление переменной в C# 1.0:
int i = 0;
Для типов-значений в C# 2.0 можно использовать знак ‘?’:
int? i = null; //можем присвоить null
В C# 3.0 компилятор позволяет явно не указывать тип переменной, тип определяется по выражению справа от знака равенства:
var i = 0; //неявно типизированная переменная
Функция
Определяется как порция кода, выполняющая определенную задачу.
Рассмотрим возможности функций в C# 1.0:
void foo(int i, ref int j, out int k, params int[] l)
{
if (l.Length > 0)
j = l[0];
k = 10;
}
int j = 5;
int k;
foo(10, ref j, out k, 1, 2, 3);
Ключевые слова ref и out позволяют вернуть значение в аргументе, а с помощью params можно сделать функцию с переменным числом аргументов.
В C# 3.0 появились функции-расширения. Они объявляются в одном классе, а вызываются как методы другого класса:
static class C // класс должен быть статическим
{
public static string foo(this int i) //статический метод и ключевое слово this
{
return "Мое значение: " + i;
}
}
MessageBox.Show(10.foo()); //у типа int появилась новая функция
В C# 4.0 ввели аргументы по-умолчанию и произвольный порядок аргументов при вызове функции:
void foo(int i, int j, int k = 0) //аргументы по-умолчанию должны быть в конце
{}
foo(i: 10, j: 20); //аргументы идут не по порядку
Класс
Тип данных, характеризуемый своими функциями и переменными.
Самый простой класс в C# 1.0:
class C
{} //нет членов класса
В C# 2.0 появились статические конструкторы:
class C
{
static C()
{} //вызовется до первого обращения к классу
}
В C# 2.0 допускается частичное объявление классов:
partial class C
{
int i;
}
partial class C //продолжение объявления того же самого типа
{
int j;
}
В C# 3.0 можно создавать анонимные типы:
var c = new { I = 10, J = 20 }; //объект с двумя свойствами
MessageBox.Show(c.J.ToString()); //свойство доступно только для чтения
Делегат
Реализует механизм обратного вызова функций. Делегаты можно передавать в параметрах функций.
Объявим делегат и функцию с параметром-делегатом:
delegate int BinaryFunction(int i, int j);
void ShowBinaryFunctionInfo(BinaryFunction op, int i, int j)
{
MessageBox.Show(op(i, j).ToString());
}
Вызов данной функции в C# 1.0:
int Sum(int i, int j)
{
return i + j;
}
BinaryFunction op = new BinaryFunction(Sum);
ShowBinaryFunctionInfo(op, 10, 20);
В C# 2.0 появились анонимные методы, позволяющие сэкономить на объявлении функции:
ShowBinaryFunctionInfo(delegate(int i, int j) { return i + j; }, 10, 20);
В C# 3.0 ввели лямбда-выражения, упрощающие анонимные методы:
ShowBinaryFunctionInfo((i, j) => { return i + j; }, 10, 20);
Свойство
Работа с объектом, как правило, осуществляется через интерфейс. Интерфейс не может содержать переменные, вместо переменных используются свойства.
Объявим интерфейс:
interface I
{
int Data { get; set; } //2 метода: get_Data и set_Data, они же 1 свойство
}
Реализация интерфейса в C# 1.0:
class C: I
{
int data = 0;
public int Data //реализовали свойство
{
get
{
return data;
}
set
{
Data = value;
}
}
}
I obj = new C();
obj.Data = 10;
MessageBox.Show(obj.Data.ToString());
Благодаря автоматическим свойствам в C# 3.0 код сильно укорачивается:
class C: I
{
public int Data {get; set;} //компилятор сам пишет нужный код
}
I obj = new C();
obj.Data = 10;
MessageBox.Show(obj.Data.ToString());
Кроме того, в C# 3.0 свойства можно инициализировать при создании объекта:
I obj1 = new C() { Data = 10 };
Обобщенное программирование
Согласно этой парадигме алгоритмы должны применяться к различным типам объектов.
Самая простая реализация этой парадигмы – использование типа object в C# 1.0:
void Swap(ref object item1, ref object item2)
{
object tmp = item1;
item1 = item2;
item2 = tmp;
}
object i = 10, j = 20;
Swap(ref i, ref j);
В C# 2.0 ввели параметризованные классы и функции:
class C<T> //пример класса
{
public T data;
}
C<int> c = new C<int>();
c.data = 10;
void Swap<T>(ref T item1, ref T item2) //пример функции
{
T tmp = item1;
item1 = item2;
item2 = tmp;
}
int i = 10, j = 20;
Swap<int>(ref i, ref j);
В C# 4.0 допускается преобразование обобщенных типов:
delegate void Action<in T>(T item); //ключевое слово in
void Display(object obj)
{
MessageBox.Show(obj.ToString());
}
class C
{ }
Action<C> display = Display; //аргумент функции object, а не C
display(new C());
Позднее связывание
На этапе компиляции может быть неизвестно точное поведение кода. В этом случае контроль корректности вызова методов осуществляется на этапе выполнения программы.
Предварительно объявим вспомогательный класс:
class C
{
public int foo(int i)
{
return i + 1;
}
}
В C# 1.0 есть библиотека System.Reflection, предоставляющая информацию о типах:
Assembly a = Assembly.GetExecutingAssembly();
object obj = a.CreateInstance("WindowsFormsApplication1.C");
MethodInfo mi = obj.GetType().GetMethod("foo");
int i = (int)mi.Invoke(obj, new object[] { 0 });
В C# 4.0 данный пример можно укоротить:
Assembly a = Assembly.GetExecutingAssembly();
dynamic obj = a.CreateInstance("WindowsFormsApplication1.C"); //динамический тип
int I = obj.foo(0);
Язык запросов
Предоставляет возможность поиска и манипулирования различными источниками данных.
В C# 3.0 появился встроенный язык запросов. Пример запроса для объектов в памяти:
var i1 = from c in new int[] {1,2,3} where c > 2 select c;
MessageBox.Show(i1.First().ToString()); //выведет 3
