Что лучше, свойства с приватной переменной или автоматические свойства?

Tolias28 · Регистрация: 18.08.2010

Студворк — интернет-сервис помощи студентам

Известно, что в классах свойства можно определить так:

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
    class MyClass
    {
        private int[] val;
 
        public int[] Val
        {
            set
            {
                val = value;
            }
            get
            {
                return val;
            }
        }
 
        public MyClass()
        {
            val = new int[100000000];
        }
 
        public int SomeMethod()
        {
            int sum = 0;
            foreach (int v in val)
            {
                sum += v;
            }
            return sum;
        }
    }

А можно вообще вот так без использования переменной val:

C#
1
2
3
4
    class MyClass2
    {
        public int Val { get; set; }
    }

Я до этого в своих программах, которые писал сам, всегда использовал первый тип, потому что размышлял вот так: внутри класса я смогу по прежнему иметь прямой доступ к переменной val(как в методе SomeMethod()), а не обращаться через свойство Val { get; set; } (как во втором примере). И это по скорости лучше, так как свойство - это тот же метод. А вызов метода, который в свою очередь вызывает уже переменную - лишние процессорные инструкции, соответственно ниже производительность(хоть и выиграш в производительности в данном случае незначительный, но все же, если учесть, что внутри класса получение переменной через свойство может вызываться огромное количество раз...)
А вот с недавнего времени хожу на одни курсы по C#, и у меня с тренером возникли немного споры по этому поводу... Многие меня упрекают, что я в классах понасоздавал лишние переменные вместо того, чтобы просто использовать автоматические свойства.

Пожалуйста, помогите мне разобраться в чем я не прав...

@IcyWind · 23.07.2012, 11:41

Я раньше c++ изучал и тоже, как и ты сейчас, не могу никак смириться с принципом "зачем писать удобнее, если можно писать, чтобы работало быстрее". Но меня убеждают в обратном

и, наверное, правильно делают. С# -это не язык для очень производительных приложений, хотя, некоторые инструменты для этого есть.
я пошёл немного дальше вас. И решил сравнить не только свойства и паблик переменные (у вас прайвет, но я из кода доступ произвожу, а вы хотите из класса), но и сами структуры и классы
вот вам программка, которая делает аналогичные опперации над классами и структурами с полями и свойствами. У меня структуры работают примерно в 20 раз быстрее. Причём, различия между структурами-свойствами и структурами-полями нет. А по классам - классы с полями работают на совсем чуть-чуть быстрее...около 2-3 процентов. Сейчас сижу на старом компе intel 4400
P.S. не забудьте, компилировать в режиме "Release", а не "Debug"
жду ваших результатов

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
using System;
using System.Collections.Generic;
using System.Linq;
 
 
namespace ConsoleApplication1
{
    public struct MyFieldStruct
    {
        public int val;
        public string name;
        
        public MyFieldStruct(int i, string s)
        {
            val = i;
            name = s;
        }
    }
 
    public struct MyPropStruct
    {
        public int val { get; set; }
 
        public string name { get; set; }
 
        public MyPropStruct(int i, string s):this()
        {
            val = i;
            name = s;
        }
    }
 
    public class MyFieldClass
    {
        public int val;
        public string name;
        
        public MyFieldClass(int i, string s)
        {
            val = i;
            name = s;
        }
    }
 
    public class MyPropClass
    {
        public int val { get; set; }
 
        public string name { get; set; }
 
        public MyPropClass(int i, string s)
        {
            val = i;
            name = s;
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            TimeSpan result1, result2, result3, result4;
            const int n = 500000000;
 
            {
                DateTime start = DateTime.Now;
                for (int i = 0; i < n; ++i)
                {
                    var cl1 = new MyFieldClass(55, "mami");
                    cl1.name = "papi";
                    cl1.val = 555;
                    cl1.name = "mami";
                    cl1.val = 55;
                }
                DateTime end = DateTime.Now;
                result3 = end - start;
                GC.Collect();
            }
            
            {
                DateTime start = DateTime.Now;
                for (int i = 0; i < n; ++i)
                {
                    var cl2 = new MyPropClass(55, "mami");
                    cl2.name = "papi";
                    cl2.val = 555;
                    cl2.name = "mami";
                    cl2.val = 55;
                }
                DateTime end = DateTime.Now;
                result4 = end - start;
                GC.Collect();
            }
 
            {
                DateTime start = DateTime.Now;
                for (int i = 0; i < n; ++i)
                {
                    var st1 = new MyFieldStruct(55, "mami");
                    st1.name = "papi";
                    st1.val = 555;
                    st1.name = "mami";
                    st1.val = 55;
                }
                DateTime end = DateTime.Now;
                result1 = end - start;
                GC.Collect();
            }
 
            {
                DateTime start = DateTime.Now;
                for (int i = 0; i < n; ++i)
                {
                    var st2 = new MyPropStruct(55, "mami");
                    st2.name = "papi";
                    st2.val = 555;
                    st2.name = "mami";
                    st2.val = 55;
                }
                DateTime end = DateTime.Now;
                result2 = end - start;
                GC.Collect();
            }
 
            
 
        
            Console.WriteLine("MyFieldStruct time = {0}", result1);
            Console.WriteLine("MyPropStruct time = {0}", result2);
            Console.WriteLine("MyFieldClass time = {0}", result3);
            Console.WriteLine("MyPropClass time = {0}", result4);
            Console.ReadKey();
        }
 
    }
}

@turbanoff · 23.07.2012, 11:46

Автоматические свойства неявно создают поля. Умный JIT умеент инлайнить свойства, убирая лишний call.
Поэтому использовать ли свойство с backend полем или autopropery - вопрос coding style, и на него не может быть дан однозначный ответ.

Добавлено через 4 минуты

Сообщение от IcyWind

У меня структуры работают примерно в 20 раз быстрее

и конечно же в каждой программе вы создаете структуры/объекты по 500 миллионов за раз.

@IcyWind · 23.07.2012, 12:01

Сообщение от turbanoff

и конечно же в каждой программе вы создаете структуры/объекты по 500 миллионов за раз.

я что-то делаю не так? я не создаю новую переменную, я просто меняю значение в полях/свойствах. То, что новая переменная не создаётся я взял из анализа WatchList для Vs. Как только я попадаю на строку, например

C#
1
var cl1 = new MyFieldClass(55, "mami");

не в первый раз, то значения полей/свойств остаются теми, которые были присвоены до выхода из итерации цикла. Или WatchList нагло врёт?)

@turbanoff · 23.07.2012, 12:09

когда вы new вызываете - тогда точно выделяется память под новую переменную.

Сообщение от IcyWind

я что-то делаю не так?

Пытаетесь убедить использовать структуры, вместо классов, основываясь на одном синтетическом тесте.

@IcyWind · 23.07.2012, 12:18

Сообщение от turbanoff

Пытаетесь убедить использовать структуры, вместо классов, основываясь на одном синтетическом тесте.

не, вы меня не так поняли, про "быстрее в 20 раз" - это просто примечание, как раз для единичного синтетического теста. Я просто привёл код, который сравнивает использование автосвойств и паблик-переменных, как в структурах, так и в классах. Т.к. разница для классов несущественна - обычно 2-3% (что граничит с погрешностью), а для структур её вообще нет, делаю вывод, что использование автосвойств - приятная "фишечка" языка, которая добавляет удобства

Tolias28 · 23.07.2012, 13:29 **[ТС]**

Сообщение от IcyWind

Я раньше c++ изучал и тоже, как и ты сейчас, не могу никак смириться с принципом "зачем писать удобнее, если можно писать, чтобы работало быстрее". Но меня убеждают в обратном

во-во. Вы как будто о мне говорите)) Кстати, C++ тоже раньше изучал.

Сообщение от IcyWind

У меня структуры работают примерно в 20 раз быстрее. Причём, различия между структурами-свойствами и структурами-полями нет. А по классам - классы с полями работают на совсем чуть-чуть быстрее...около 2-3 процентов

Ну то, что структуры работают намного быстрее, у меня не вызывает никаких удивлений и вопросов) Структура - это ж значимый тип, который хранит свое значение прямо в стеке. А стек-память имеет более высокую скорость доступа, чем куча. А классы как раз и хранят свои значения в куче, а в стеке они сохраняют лишь ссылку на адрес в куче.

Сообщение от IcyWind

жду ваших результатов

Провел эксперименты и открыл для себя две удивительные вещи:
1. Скорость работы с автоматическими свойствами в структур даже немного выше, чем доступ к полям(!!!). Я запускал программу несколько раз и скорость свойств всегда была выше, чем полей. То есть, если смотреть даже только на одно быстродействие, то их уже предпочтительнее использовать в структурах.
2. Быстродействие программы зависит от версии фреймворка, при том на очень внушительную цифру. Я пробовал компилить exeшник в разных версиях. На версиях 2.0, 3.0, 3.5 скорость практически одинакова(разница лишь ±1 секунда). А вот на четвертом фреймворке... короче цифры сами все говорят: (время наведено в секундах)

-------------------- FW2-3.5 ---- FW4

Поле структуры ----- 1.687 ----- 1.718

Свойство структуры - 4.046 ----- 1.093 (в 4 раза быстрее!)

Поле класса -------- 33.796 ---- 16.421 (в 2 раза быстрее!)

Свойство класса ---- 32.171 ---- 17.343 (в 2 раза быстрее!)

Кстати, свойства работают быстрее за поля в структурах только в 4-ом фреймворке, а в версиях ниже этой приятной аномалии не наблюдается.

Что касается свойств в классах, то таки да, скорость практически такая же как и у полей(она лишь на несколько процентов ниже за доступ к полям).

Выводы, которые можно из этих экспериментов сделать:
1. Если хотите, чтобы ваша программа быстрее работала, не понижайте версию FW из-за юзеров, которые ленятся его себе устанавливать, а используйте намного производительный FW4.
2. В структурах оптимальнее использовать свойства, чем поля (хоть это и противоречит сложившемуся использованию структур - поля в структурах и так публичные, там незачем свойства писать)
3. Можно использовать свойства в классах вместо полей. Падение скорости практически незаметное.

Tolias28 · 23.07.2012, 13:39 **[ТС]**

Очень хочется, чтобы кто-то еще протестровал разницу в скорости в 4-ой и 3-ей версии фреймворка и поделился своими результатами. Интересно, у всех ли такая большая разница в скорости.

@turbanoff · 23.07.2012, 13:46

Сообщение от Tolias28

Ну то, что структуры работают намного быстрее, у меня не вызывает никаких удивлений и вопросов) Структура - это ж значимый тип, который хранит свое значение прямо в стеке. А стек-память имеет более высокую скорость доступа, чем куча. А классы как раз и хранят свои значения в куче, а в стеке они сохраняют лишь ссылку на адрес в куче.

Неверно, почти по всем пунктам.
Структуры не быстрее классов. Структуры всегда копируются полностью: при вызове метода, при возврате их из метода, что при больших размерах структуры - существенно.
Стек-память имеет не более высокую скорость, чем куча, откуда вы такое взяли?

Tolias28 · 23.07.2012, 14:00 **[ТС]**

Сообщение от turbanoff

Структуры всегда копируются полностью: при вызове метода, при возврате их из метода, что при больших размерах структуры - существенно

Скажите пожалуйста, где я выше говорил противоположное этому? В том, что вы назвали, структура действительно проигрывает в скорости и я даже не пытаюсь об этом спорить. Ну а вот если обращаться к полям и свойствам структуры, то скорость колосально выше за классы. Об этом говорят результаты тестов(посмотрите на мой скрин во вложении выше). Или я вам наверное вру? Ну тогда приведите свои тесты, сделанные программой с кодом в ссобщении №2 Посмотрим все вместе

Сообщение от turbanoff

Стек-память имеет не более высокую скорость, чем куча, откуда вы такое взяли?

Я не помню, но где-то такое уже читал. Ну и на практике доступ к структуре действительно происходит намного быстрей, чем к классу (опять же смотрите результаты тестов, если словам не верите).
Ну сами смотрите: чтобы узнать значение структуры, нужно обратиться к определенному адресу в пространстве стека. Все, значение мы имеем.
Но чтобы достучаться к значению класса, нужно опять же сперва обратиться к определенному адресу в пространстве стека. Прочитать с этого места адрес, по которому хранится значение в куче. Найти этот адрес в куче, и только после этого мы получим значение.

Может я в чем-то мелком допустился ошибки, но в общем так ведь все и происходит. Не так ли?

@Savvy · 23.07.2012, 14:34

HTML5
1
2
3
4
5
6
7
8
+--------------------+-------+-------+-------+-------+-------+-------+
|                    |  4.0  | 4.0CP |  3.5  | 3.5CP |  3.0  |  2.0  |
+--------------------+-------+-------+-------+-------+-------+-------+
| Поле структуры     | 0.335 | 0.335 | 0.502 | 0.503 | 0.511 | 0.514 |
| Свойство структуры | 0.335 | 0.335 | 1.176 | 1.172 | 1.171 | 1.172 |
| Поле класса        | 4.510 | 4.523 | 4.567 | 5.377 | 5.173 | 4.795 |
| Свойство класса    | 5.070 | 5.126 | 5.548 | 5.817 | 5.590 | 5.484 |
+--------------------+-------+-------+-------+-------+-------+-------+

каждой версии по 3 теста. взято среднее значение.
Машина: Intel I3 540, 4Gb RAM, Win7 x64 7601

Tolias28 · 23.07.2012, 14:40 **[ТС]**

Savvy, спасибо! У вас почти нет разницы в скорости от версии... только свойства структуры быстрее пашут на четвертой версии, это хорошо видно.
Интересно, почему у меня такая большая разница в скорости четвертой версии от других. Мне аж прям очень стало интересно, и объяснения этому что-то не нахожу))
А у вас какая ОСь и сколько бит?

@Savvy · 23.07.2012, 14:55

Сообщение от Tolias28

А у вас какая ОСь и сколько бит?

Сообщение от Savvy

Win7 x64 7601

пока не знаю что и ответить, мб кто еще скинет результаты.

@IcyWind · 23.07.2012, 15:41

Сообщение от turbanoff

Структуры всегда копируются полностью: при вызове метода, при возврате их из метода, что при больших размерах структуры - существенно.

Раз уж речь зашла о структурах, то хотел бы уточнить про передачу объектов-значений в метод через модификатор ref. Если делать так, то структура же перестаёт копироваться?

@turbanoff · 23.07.2012, 17:13

Сообщение от IcyWind

Если делать так, то структура же перестаёт копироваться?

да, однако это не всегда приемлемо. Например, сохранить ref ссылку, а если это требуется, то придется опять же копировать всю структуру.

Добавлено через 4 минуты
IcyWind, Переделайте тогда уж тест, засекая время с помощью StopWatch, будут более объективные результаты.

Psilon · 23.07.2012, 20:03

Я немного изменил методику тестирования, результаты ниже:

C#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
using System;
using System.Diagnostics;
namespace Test
{
    public struct Result
    {
        public long Time;
        public long Ticks;
 
    }
    public struct MyFieldStruct
    {
        public int Val;
        public string Name;
 
        public MyFieldStruct(int i, string s)
        {
            Val = i;
            Name = s;
        }
    }
 
    public struct MyPropStruct
    {
        public int Val { get; set; }
 
        public string Name { get; set; }
 
        public MyPropStruct(int i, string s)
            : this()
        {
            Val = i;
            Name = s;
        }
    }
 
    public class MyFieldClass
    {
        public int Val;
        public string Name;
 
        public MyFieldClass(int i, string s)
        {
            Val = i;
            Name = s;
        }
    }
 
    public class MyPropClass
    {
        public int Val { get; set; }
 
        public string Name { get; set; }
 
        public MyPropClass(int i, string s)
        {
            Val = i;
            Name = s;
        }
    }
 
    class Program
    {
        static void Main()
        {
            Result result1, result2, result3, result4;
            const int n = 500000000;
 
            {
                var start = new Stopwatch();
                start.Start();
                for (int i = 0; i < n; ++i)
                {
                    var cl1 = new MyFieldClass(55, "mami");
                    cl1.Name = "papi";
                    cl1.Val = 555;
                    cl1.Name = "mami";
                    cl1.Val = 55;
                }
                result3.Ticks = start.ElapsedTicks;
                result3.Time = start.ElapsedMilliseconds;
                GC.Collect();
            }
 
            {
                var start = new Stopwatch();
                start.Start();
                for (int i = 0; i < n; ++i)
                {
                    var cl2 = new MyPropClass(55, "mami");
                    cl2.Name = "papi";
                    cl2.Val = 555;
                    cl2.Name = "mami";
                    cl2.Val = 55;
                }
                result4.Ticks = start.ElapsedTicks;
                result4.Time = start.ElapsedMilliseconds;
                GC.Collect();
            }
 
            {
                var start = new Stopwatch();
                start.Start();
                for (int i = 0; i < n; ++i)
                {
                    var st1 = new MyFieldStruct(55, "mami");
                    st1.Name = "papi";
                    st1.Val = 555;
                    st1.Name = "mami";
                    st1.Val = 55;
                }
                result1.Ticks = start.ElapsedTicks;
                result1.Time = start.ElapsedMilliseconds;
                GC.Collect();
            }
 
            {
                var start = new Stopwatch();
                start.Start();
                for (int i = 0; i < n; ++i)
                {
                    var st2 = new MyPropStruct(55, "mami");
                    st2.Name = "papi";
                    st2.Val = 555;
                    st2.Name = "mami";
                    st2.Val = 55;
                }
                result2.Ticks = start.ElapsedTicks;
                result2.Time = start.ElapsedMilliseconds;
                GC.Collect();
            }
 
 
 
 
            Console.WriteLine("MyFieldStruct milliseconds = {0} , ticks = {1}", result1.Time,result1.Ticks);
            Console.WriteLine("MyPropStruct milliseconds = {0}, ticks = {1}", result2.Time, result2.Ticks);
            Console.WriteLine("MyFieldClass milliseconds = {0}, ticks = {1}", result3.Time, result3.Ticks);
            Console.WriteLine("MyPropClass milliseconds = {0}, ticks = {1}", result4.Time, result4.Ticks);
            Console.ReadKey();
        }
 
    }
}

Машина: Core i7-3615QM, 8GB RAM, win 7 x64 sp1, Release, FW 4.0CP

Первый скриншот - просто сделал (причем запускал из студии), второй - после перезагрузки, запускал экзешник

@Noob.net · 23.07.2012, 21:46

Сообщение от Tolias28

Интересно, почему у меня такая большая разница в скорости четвертой версии от других.

Насколько я знаю в 4 пофиксили GC,а недавно прочел что в 4 версии моно добились еще большего успеха в сборке мусора и скорости работы)

@Muxto · 07.10.2013, 21:24

я чего то не пойму, зачем создавать наследуемый конструктор?

public MyPropStruct(int i, string s) : this()

@IcyWind · 07.10.2013, 21:34

Сообщение от Muxto

я чего то не пойму, зачем создавать наследуемый конструктор?

public MyPropStruct(int i, string s) : this()

это просто вызов конструктора по умолчанию
Если ты копируешь код в студию (удалив его вызов) и попробуешь запустить, то получишь очень содержательное сообщение об ошибке)
копирую сюда: Ошибка Резервное поле для автоматически реализованного свойства"MyPropStruct.Val" должно быть полностью определено до возврата управления в вызывающий метод. Попробуйте использовать вызов конструктора по умолчанию из инициализатора конструктора.
и туда же
Ошибка Невозможно использовать объект this, пока не будут назначены все его поля

@_Mutex · 07.10.2013, 23:20

Сообщение от Tolias28

Известно, что в классах свойства можно определить так:

Я до этого в своих программах, которые писал сам, всегда использовал первый тип, потому что размышлял вот так: внутри класса я смогу по прежнему иметь прямой доступ к переменной val(как в методе SomeMethod()), а не обращаться через свойство Val { get; set; } (как во втором примере). И это по скорости лучше, так как свойство - это тот же метод. А вызов метода, который в свою очередь вызывает уже переменную - лишние процессорные инструкции, соответственно ниже производительность(хоть и выиграш в производительности в данном случае незначительный, но все же, если учесть, что внутри класса получение переменной через свойство может вызываться огромное количество раз...)
А вот с недавнего времени хожу на одни курсы по C#, и у меня с тренером возникли немного споры по этому поводу... Многие меня упрекают, что я в классах понасоздавал лишние переменные вместо того, чтобы просто использовать автоматические свойства.

Пожалуйста, помогите мне разобраться в чем я не прав...

Сейчас о производительности так рассуждают только те кто остался в далеких 80х 90х. Когда компьютеры были с кБ памяти, а процессоры с МГц. Тогда "отцы" думали как быстрее, и изобретали каждый свой велосипед.

Со временем производительность перестала быть узким местом в программировании, а на первый план вышли концептуальные понятия, удобство, и главное скорость написания большого объема кода.
Но некоторые так и остались в тех же временах, изобретают велосипеды, тешатся мнимой производительностью, пишут на языках 80х-90х годов (привет с,с++) и т.д.

Для тебя реализация- черный ящик, стало быть и вопросы эти не должны заботить.

Новые блоги и статьи Все статьи Все блоги /
SDL3 для Web (WebAssembly): Реализация движения на Box2D v3 - трение и коллизии с повёрнутыми стенами 8Observer8 20.02.2026 Содержание блога Box2D позволяет легко создать главного героя, который не проходит сквозь стены и перемещается с заданным трением о препятствия, которые можно располагать под углом, как верхнее. . .	Конвертировать закладки radiotray-ng в m3u-плейлист damix 19.02.2026 Это можно сделать скриптом для PowerShell. Использование . \СonvertRadiotrayToM3U. ps1 <path_to_bookmarks. json> Рядом с файлом bookmarks. json появится файл bookmarks. m3u с результатом. # Check if. . .	Семь CDC на одном интерфейсе: 5 U[S]ARTов, 1 CAN и 1 SSI Eddy_Em 18.02.2026 Постепенно допиливаю свою "многоинтерфейсную плату". Выглядит вот так: https:/ / www. cyberforum. ru/ blog_attachment. php?attachmentid=11617&stc=1&d=1771445347 Основана на STM32F303RBT6. На борту пять. . .	Камера Toupcam IUA500KMA Eddy_Em 12.02.2026 Т. к. у всяких "хикроботов" слишком уж мелкий пиксель, для подсмотра в ESPriF они вообще плохо годятся: уже 14 величину можно рассмотреть еле-еле лишь на экспозициях под 3 секунды (а то и больше),. . .
И ясному Солнцу zbw 12.02.2026 И ясному Солнцу, и светлой Луне. В мире покоя нет и люди не могут жить в тишине. А жить им немного лет.	«Знание-Сила» zbw 12.02.2026 «Знание-Сила» «Время-Деньги» «Деньги -Пуля»	SDL3 для Web (WebAssembly): Подключение Box2D v3, физика и отрисовка коллайдеров 8Observer8 12.02.2026 Содержание блога Box2D - это библиотека для 2D физики для анимаций и игр. С её помощью можно определять были ли коллизии между конкретными объектами и вызывать обработчики событий столкновения. . . .	SDL3 для Web (WebAssembly): Загрузка PNG с прозрачным фоном с помощью SDL_LoadPNG (без SDL3_image) 8Observer8 11.02.2026 Содержание блога Библиотека SDL3 содержит встроенные инструменты для базовой работы с изображениями - без использования библиотеки SDL3_image. Пошагово создадим проект для загрузки изображения. . .

Tolias28 213 / 139 / 8 Регистрация: 18.08.2010 Сообщений: 1,018
	23.07.2012, 13:39 [ТС]
	Очень хочется, чтобы кто-то еще протестровал разницу в скорости в 4-ой и 3-ей версии фреймворка и поделился своими результатами. Интересно, у всех ли такая большая разница в скорости. 0

Tolias28 213 / 139 / 8 Регистрация: 18.08.2010 Сообщений: 1,018
	23.07.2012, 14:40 [ТС]
	Savvy, спасибо! У вас почти нет разницы в скорости от версии... только свойства структуры быстрее пашут на четвертой версии, это хорошо видно. Интересно, почему у меня такая большая разница в скорости четвертой версии от других. Мне аж прям очень стало интересно, и объяснения этому что-то не нахожу)) А у вас какая ОСь и сколько бит? 0

@Muxto 1 / 1 / 0 Регистрация: 07.05.2012 Сообщений: 16
	07.10.2013, 21:24
	я чего то не пойму, зачем создавать наследуемый конструктор? public MyPropStruct(int i, string s) : this() 0