Автор: Виталий Алферов
Для оценки качества диагностик анализатора C# кода PVS-Studio мы проверяем большое количество различных проектов. Т.к. проекты пишутся разными людьми в различных командах в разных компаниях, нам приходится сталкиваться с различными стилями, сокращениями, да и просто возможностями, которые предлагает язык C# программистам. В этой статье я хочу обзорно пройтись по некоторым моментам, которые предлагает нам замечательный язык C#, и по тем проблемам, на которые можно наткнуться при его использовании.
Свойства и что с ними можно делать
Мы все знаем, что свойства - это пара функций - аксессор и мутатор - для изменения и чтения значения в каком-то поле. Ну, или по крайней мере так было до версии языка C# 3.0. Т.е. классически они должны выглядеть вот так:
| C# | 1
2
3
4
5
6
7
8
9
| class A
{
int index;
public int Index
{
get { return index; }
set { index = value; }
}
} |
|
Начнем понемногу. В стандарте C# 3.0 появилась всем известная возможность опустить поле, т.е. записать так:
| C# | 1
2
3
4
| class A
{
public int Index { get; set; }
} |
|
| C# | 1
2
3
4
| class A
{
public int Index { get; }
} |
|
Свойства и поля можно инициализировать различными способами. Например, так:
| C# | 1
2
3
4
| class A
{
public List<int> Numbers { get; } = new List<int>();
} |
|
| C# | 1
2
3
4
| class A
{
public List<int> Numbers = new List<int>();
} |
|
| C# | 1
2
3
4
| class A
{
public List<int> Numbers => new List<int>();
} |
|
| C# | 1
2
3
4
| class A
{
public List<int> Numbers { get { return new List<int>(); } }
} |
|
| C# | 1
2
3
4
| A a = new A();
a.Numbers.Add(10);
a.Numbers.Add(20);
a.Numbers.Add(30); |
|
Интересные свойства свойств на этом не заканчиваются. Как я уже сказал, свойство - это пара функций, а в функциях никто не мешает менять параметры, которые туда приходят.
Следующий код прекрасно компилируется и даже работает.
| C# | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| class A
{
int index;
public int Index
{
get { return index; }
set {
value = 20;
index = value; }
}
}
static void Main(string[] args)
{
A a = new A();
a.Index = 10;
Console.WriteLine(a.Index);
} |
|
Казалось бы, зачем кому-то сдалось записывать значение 20 в value? Оказывается, даже в этом может быть смыл. Но для пояснения этого смысла, мы немного отвлекаемся от свойств и расскажем о ключевом символе @. Данный ключевой символ поваляет создавать переменные схожие по написаю с ключевыми словами, но никто не запрещает данный символ пихать куда душа пожелает, например:
| C# | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| class A
{
public int index;
public void CopyIndex(A @this)
{
this.@index = @this.index;
}
}
static void Main(string[] args)
{
A a = new A();
@a.@index = 10;
a.@CopyIndex(new A() { @index = 20 });
Console.WriteLine(a.index);
} |
|
На самом деле, символ @ необходим только в одном месте, когда пишем имя параметра @this в функции CopyIndex. В других местах это просто лишний код, который к тому же затрудняет понимание написанного.
С этими знаниями вернемся к свойствам и предположим, что у нас есть следующий класс:
| C# | 1
2
3
4
5
6
7
8
9
10
11
12
13
| class A
{
int value;
public int Value
{
get { return @value; }
set { @value = value; }
}
public A()
{
value = 5;
}
} |
|
| C# | 1
2
3
4
5
6
| static void Main(string[] args)
{
A a = new A();
a.Value = 10;
Console.WriteLine(a.Value);
} |
|
Инициализация Dictionary
Для начала вспомним, как можно инициализировать массивы:
| C# | 1
2
3
4
5
6
| string[] test1 = new string[] { "1", "2", "3" };
string[] test2 = new[] { "1", "2", "3" };
string[] test3 = { "1", "2", "3" };
string[,] test4 = { { "11", "12" },
{ "21", "22" },
{ "31", "32" } }; |
|
| C# | 1
| List<string> test2 = new List<string>(){ "1", "2", "3" }; |
|
| C# | 1
2
3
4
| Dictionary<string, int> test =
new Dictionary<string, int>() { { "a-a", 1 },
{ "b-b", 2 },
{ "c-c", 3 } }; |
|
| C# | 1
2
3
4
5
6
| Dictionary<string, int> test =
new Dictionary<string, int>() {
["a-a"] = 1,
["b-b"] = 2,
["c-c"] = 3
}; |
|
Немного о LINQ запросах
LINQ запросы в принципе сама по себе вещь удобная. Собираем цепочку с необходимыми выборками и на выходе получаем необходимую информацию. Для начала опишем пару приятных моментов, которые могут не прийти в голову, пока сам не увидишь их. Для начала рассмотрим базовый пример:
| C# | 1
2
3
4
| void Foo(List<int> numbers1, List<int> numbers2) {
var selection1 = numbers1.Where(index => index > 10);
var selection2 = numbers2.Where(index => index > 10);
} |
|
| C# | 1
2
3
4
5
| void Foo(List<int> numbers1, List<int> numbers2) {
Func<int, bool> whereFunc = index => index > 10;
var selection1 = numbers1.Where(index => whereFunc(index));
var selection2 = numbers2.Where(index => whereFunc(index));
} |
|
| C# | 1
2
3
4
5
| void Foo(List<int> numbers1, List<int> numbers2) {
Func<int, bool> whereFunc = index => index > 10;
var selection1 = numbers1.Where(whereFunc);
var selection2 = numbers2.Where(whereFunc);
} |
|
Теперь немного о нюансах работы LINQ выражений. Например, строчка кода не приведет к моментальной выборке данных из коллекции numbers1.
| C# | 1
| IEnumerable<int> selection = numbers1.Where(whereFunc); |
|
| C# | 1
| List<int> listNumbers = selection.ToList(); |
|
| C# | 1
2
3
4
5
| 0 :
1 :
2 : 1
3 : 1, 2
4 : 1, 2, 3 |
|
| C# | 1
2
| static Dictionary<int, IEnumerable<int>> Foo(int[] numbers)
{ .... } |
|
| C# | 1
2
3
4
5
| foreach (KeyValuePair<int, IEnumerable<int>> subArray in
Foo(new[] { 1, 2, 3, 4, 5 }))
Console.WriteLine(string.Format("{0} : {1}",
subArray.Key,
string.Join(", ", subArray.Value))); |
|
| C# | 1
2
3
4
5
6
7
| static Dictionary<int, IEnumerable<int>> Foo(int[] numbers)
{
var result = new Dictionary<int, IEnumerable<int>>();
for (int i = 0; i < numbers.Length; i++)
result[i] = numbers.Where(index => index < i);
return result;
} |
|
Результатом работы такой программы будет вот такой текст в консоли:
| C# | 1
2
3
4
5
| 0 : 1, 2, 3, 4
1 : 1, 2, 3, 4
2 : 1, 2, 3, 4
3 : 1, 2, 3, 4
4 : 1, 2, 3, 4 |
|
Недокументированные костыли на C#
Язык С++ известен своими хаками, обходными путями и прочими костылями, чего стоит серия функций XXX_cast. Считается, что в C# такого нет. На самом деле и это не совсем правда...
Начнем, пожалуй, с нескольких слов:
- __makeref
- __reftype
- __refvalue
Этих слов нет ни в IntelliSense, да и в MSDN нет официального описания к ним.
Так что это за чудо-слова такие?
__makeref принимает объект и возвращает некую "ссылку" на объект в виде объекта типа TypedReference. А, собственно, слова __reftype и __refvalue позволяют из этой "ссылки" узнать соответственно тип объекта и значение объекта по данной "ссылке".
Рассмотрим пример:
| C# | 1
2
3
4
5
6
7
8
9
10
11
| struct A { public int Index { get; set; } }
static void Main(string[] args)
{
A a = new A();
a.Index = 10;
TypedReference reference = __makeref(a);
Type typeRef = __reftype(reference);
Console.WriteLine(typeRef); //=> ConsoleApplication23.Program+A
A valueRef = __refvalue(reference, A);
Console.WriteLine(valueRef.Index); //=> 10
} |
|
| C# | 1
2
3
4
5
6
7
8
9
| static void Main(string[] args)
{
A a = new A();
a.Index = 10;
dynamic dynam = a;
Console.WriteLine(dynam.GetType());
A valuDynam = (A)dynam;
Console.WriteLine(valuDynam.Index);
} |
|
| C# | 1
2
3
4
5
6
7
8
9
10
| static void Main(string[] args)
{
TypedReference reference = __makeref(a);
SetVal(reference);
Console.WriteLine(__refvalue(reference, A).Index);
}
static void SetVal(TypedReference reference)
{
__refvalue(reference, A) = new A() { Index = 20 };
} |
|
| C# | 1
2
3
4
5
6
7
8
9
10
| static void Main(string[] args)
{
dynamic dynam = a;
SetVal(ref dynam);
Console.WriteLine(((A)dynam).Index);
}
static void SetVal(ref dynamic dynam)
{
dynam = new A() { Index = 20 };
} |
|
Кроме выше описанных, есть еще одно чудо-слово __arglist, которое позволяет сделать функцию с переменным числом параметров, да еще и любого типа.
| C# | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| static void Main(string[] args)
{
Foo(__arglist(1, 2.0, "3", new A[0]));
}
public static void Foo(__arglist)
{
ArgIterator iterator = new ArgIterator(__arglist);
while (iterator.GetRemainingCount() > 0)
{
TypedReference typedReference =
iterator.GetNextArg();
Console.WriteLine("{0} / {1}",
TypedReference.ToObject(typedReference),
TypedReference.GetTargetType(typedReference));
}
} |
|
| C# | 1
2
3
4
5
| function sum() {
....
for(var i=0; i < arguments.length; i++)
s += arguments[i]
} |
|
Заключение
В заключение хочется сказать, что и С++ и C# - весьма свободные по грамматике языки, и тем самым с одной стороны удобны в использовании, но с другой не защищают от опечаток. Есть укоренившееся мнение, что в С# нельзя ошибаться так, как в С++, – на самом деле это вовсе не так. В данной статье приведены весьма интересные, на мой взгляд, возможности языка, но львиная доля ошибок в C# состоит не в них, а при написании обычных индукций if, как, например, в проекте Infragistics.
| C# | 1
2
3
4
5
6
7
8
9
| public bool IsValid
{
get {
var valid =
double.IsNaN(Latitude) || double.IsNaN(Latitude) ||
this.Weather.DateTime == Weather.DateTimeInitial;
return valid;
}
} |
|
Внимание рассеивается чаще всего именно в таких моментах, а потом долгие поиски "непонятно чего непонятно где". Так что не упускайте возможность уберечь себя от ошибок с помощью анализатора кода PVS-Studio.
|
