Skip to content

Commit 3d5f863

Browse files
jafinardalis
jafin
and
ardalis
authored
task (build warnings): Minor refactor to remove build warnings. (#108)
- Whitespace removal - Non-existant mvc ruleset check - empty summary tags - redundant comments with no added value. - whitespace Co-authored-by: Steve Smith <[email protected]>
1 parent 71e512d commit 3d5f863

File tree

54 files changed

+381
-537
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

54 files changed

+381
-537
lines changed

‎benchmarks/SmartEnum.Benchmarks/Config.cs

+3-4
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,10 @@
11
namespace Ardalis.SmartEnum.Benchmarks
22
{
3-
using BenchmarkDotNet.Attributes;
43
using BenchmarkDotNet.Columns;
54
using BenchmarkDotNet.Configs;
65
using BenchmarkDotNet.Diagnosers;
7-
using BenchmarkDotNet.Jobs;
8-
6+
using BenchmarkDotNet.Jobs;
7+
98
public class Config : ManualConfig
109
{
1110
public Config()
@@ -14,5 +13,5 @@ public Config()
1413
Add(MemoryDiagnoser.Default);
1514
Add(new TagColumn("Library", name => name.Split('_')[0]));
1615
}
17-
}
16+
}
1817
}

‎benchmarks/SmartEnum.Benchmarks/EqualsBenchmarks.cs

+13-14
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,5 @@
11
namespace Ardalis.SmartEnum.Benchmarks
22
{
3-
using System;
43
using BenchmarkDotNet.Attributes;
54

65
[Config(typeof(Config))]
@@ -13,19 +12,19 @@ public class EqualsBenchmarks
1312
public int Enum_GetHashCode() => TestEnum.One.GetHashCode();
1413

1514
[Benchmark]
16-
public bool Enum_Equals_SameValue() => TestEnum.One.Equals(TestEnum.One);
15+
public bool Enum_Equals_SameValue() => TestEnum.One.Equals(TestEnum.One);
1716

1817
[Benchmark]
19-
public bool Enum_Equals_DifferentValue() => TestEnum.One.Equals(TestEnum.Two);
18+
public bool Enum_Equals_DifferentValue() => TestEnum.One.Equals(TestEnum.Two);
2019

2120
[Benchmark]
22-
public bool Enum_Equals_DifferentType() => TestEnum.One.Equals(TestEnum2.One);
21+
public bool Enum_Equals_DifferentType() => TestEnum.One.Equals(TestEnum2.One);
2322

2423
[Benchmark]
2524
public bool Enum_EqualOperator() => TestEnum.One == TestEnum.Two;
2625

2726
[Benchmark]
28-
public bool Enum_NotEqualOperator() => TestEnum.One != TestEnum.Two;
27+
public bool Enum_NotEqualOperator() => TestEnum.One != TestEnum.Two;
2928

3029
////////////////////////////////////////////////////////////////////////////////
3130
// Constant
@@ -34,22 +33,22 @@ public class EqualsBenchmarks
3433
public int Constant_GetHashCode() => TestConstant.One.GetHashCode();
3534

3635
[Benchmark]
37-
public bool Constant_Equals_Null() => TestConstant.One.Equals((TestConstant)null);
36+
public bool Constant_Equals_Null() => TestConstant.One.Equals((TestConstant)null);
3837

3938
[Benchmark]
40-
public bool Constant_Equals_SameValue() => TestConstant.One.Equals(TestConstant.One);
39+
public bool Constant_Equals_SameValue() => TestConstant.One.Equals(TestConstant.One);
4140

4241
[Benchmark]
43-
public bool Constant_Equals_DifferentValue() => TestConstant.One.Equals(TestConstant.Two);
42+
public bool Constant_Equals_DifferentValue() => TestConstant.One.Equals(TestConstant.Two);
4443

4544
[Benchmark]
46-
public bool Constant_Equals_DifferentType() => TestConstant.One.Equals(TestConstant2.One);
45+
public bool Constant_Equals_DifferentType() => TestConstant.One.Equals(TestConstant2.One);
4746

4847
[Benchmark]
4948
public bool Constant_EqualOperator() => TestConstant.One == TestConstant.Two;
5049

5150
[Benchmark]
52-
public bool Constant_NotEqualOperator() => TestConstant.One != TestConstant.Two;
51+
public bool Constant_NotEqualOperator() => TestConstant.One != TestConstant.Two;
5352

5453
////////////////////////////////////////////////////////////////////////////////
5554
// SmartEnum
@@ -58,21 +57,21 @@ public class EqualsBenchmarks
5857
public int SmartEnum_GetHashCode() => TestSmartEnum.One.GetHashCode();
5958

6059
[Benchmark]
61-
public bool SmartEnum_Equals_Null() => TestSmartEnum.One.Equals((TestSmartEnum)null);
60+
public bool SmartEnum_Equals_Null() => TestSmartEnum.One.Equals((TestSmartEnum)null);
6261

6362
[Benchmark]
6463
public bool SmartEnum_Equals_SameValue() => TestSmartEnum.One.Equals(TestSmartEnum.One);
6564

6665
[Benchmark]
67-
public bool SmartEnum_Equals_DifferentValue() => TestSmartEnum.One.Equals(TestSmartEnum.Two);
66+
public bool SmartEnum_Equals_DifferentValue() => TestSmartEnum.One.Equals(TestSmartEnum.Two);
6867

6968
[Benchmark]
70-
public bool SmartEnum_Equals_DifferentType() => TestSmartEnum.One.Equals(TestSmartEnum2.One);
69+
public bool SmartEnum_Equals_DifferentType() => TestSmartEnum.One.Equals(TestSmartEnum2.One);
7170

7271
[Benchmark]
7372
public bool SmartEnum_EqualOperator() => TestSmartEnum.One == TestSmartEnum.Two;
7473

7574
[Benchmark]
76-
public bool SmartEnum_NotEqualOperator() => TestSmartEnum.One != TestSmartEnum.Two;
75+
public bool SmartEnum_NotEqualOperator() => TestSmartEnum.One != TestSmartEnum.Two;
7776
}
7877
}

‎benchmarks/SmartEnum.Benchmarks/FromNameBenchmarks.cs

+29-29
Original file line numberDiff line numberDiff line change
@@ -25,17 +25,17 @@ public TestEnum Enum_FromName_Invalid()
2525
{
2626
return Enum.Parse<TestEnum>("Invalid");
2727
}
28-
catch(Exception)
28+
catch (Exception)
2929
{
3030
return TestEnum.One;
3131
}
3232
}
33-
33+
3434
[Benchmark]
3535
public TestEnum Enum_FromName_one_IgnoreCase() => Enum.Parse<TestEnum>("one", true);
3636

3737
[Benchmark]
38-
public TestEnum Enum_FromName_ten_IgnoreCase() => Enum.Parse<TestEnum>("ten", true);
38+
public TestEnum Enum_FromName_ten_IgnoreCase() => Enum.Parse<TestEnum>("ten", true);
3939

4040

4141
[Benchmark]
@@ -45,11 +45,11 @@ public TestEnum Enum_FromName_Invalid_IgnoreCase()
4545
{
4646
return Enum.Parse<TestEnum>("Invalid", true);
4747
}
48-
catch(Exception)
48+
catch (Exception)
4949
{
5050
return TestEnum.One;
5151
}
52-
}
52+
}
5353

5454
////////////////////////////////////////////////////////////////////////////////
5555
// Enums.NET
@@ -67,35 +67,35 @@ public TestEnum EnumsNET_FromName_Invalid()
6767
{
6868
return Enums.Parse<TestEnum>("Invalid");
6969
}
70-
catch(Exception)
70+
catch (Exception)
7171
{
7272
return TestEnum.One;
7373
}
7474
}
75-
75+
7676
[Benchmark]
7777
public TestEnum EnumsNET_TryFromName_One()
7878
{
79-
if(Enums.TryParse<TestEnum>("One", out var result))
79+
if (Enums.TryParse<TestEnum>("One", out var result))
8080
return result;
8181
return TestEnum.One;
8282
}
8383

8484
[Benchmark]
8585
public TestEnum EnumsNET_TryFromName_Ten()
8686
{
87-
if(Enums.TryParse<TestEnum>("Ten", out var result))
87+
if (Enums.TryParse<TestEnum>("Ten", out var result))
8888
return result;
8989
return TestEnum.One;
9090
}
91-
91+
9292
[Benchmark]
9393
public TestEnum EnumsNET_TryFromName_Invalid()
9494
{
95-
if(Enums.TryParse<TestEnum>("Invalid", out var result))
95+
if (Enums.TryParse<TestEnum>("Invalid", out var result))
9696
return result;
9797
return TestEnum.One;
98-
}
98+
}
9999

100100
////////////////////////////////////////////////////////////////////////////////
101101
// Constant
@@ -113,7 +113,7 @@ public TestConstant Constant_GetFor_Invalid()
113113
{
114114
return global::Constant.Constant<string, TestConstant>.GetFor("Invalid");
115115
}
116-
catch(Exception)
116+
catch (Exception)
117117
{
118118
return TestConstant.One;
119119
}
@@ -132,7 +132,7 @@ public TestConstant Constant_GetOrDefaultFor_Invalid()
132132
{
133133
return global::Constant.Constant<string, TestConstant>.GetOrDefaultFor("Invalid");
134134
}
135-
catch(Exception)
135+
catch (Exception)
136136
{
137137
return TestConstant.One;
138138
}
@@ -154,17 +154,17 @@ public TestSmartEnum SmartEnum_FromName_Invalid()
154154
{
155155
return TestSmartEnum.FromName("Invalid", false);
156156
}
157-
catch(SmartEnumNotFoundException)
157+
catch (SmartEnumNotFoundException)
158158
{
159159
return null;
160160
}
161161
}
162-
162+
163163
[Benchmark]
164164
public TestSmartEnum SmartEnum_FromName_one_IgnoreCase() => TestSmartEnum.FromName("one", true);
165165

166166
[Benchmark]
167-
public TestSmartEnum SmartEnum_FromName_ten_IgnoreCase() => TestSmartEnum.FromName("ten", true);
167+
public TestSmartEnum SmartEnum_FromName_ten_IgnoreCase() => TestSmartEnum.FromName("ten", true);
168168

169169

170170
[Benchmark]
@@ -174,59 +174,59 @@ public TestSmartEnum SmartEnum_FromName_Invalid_IgnoreCase()
174174
{
175175
return TestSmartEnum.FromName("Invalid", true);
176176
}
177-
catch(SmartEnumNotFoundException)
177+
catch (SmartEnumNotFoundException)
178178
{
179179
return null;
180180
}
181-
}
182-
181+
}
182+
183183
[Benchmark]
184184
public TestSmartEnum SmartEnum_TryFromName_One()
185185
{
186-
if(TestSmartEnum.TryFromName("One", false, out var result))
186+
if (TestSmartEnum.TryFromName("One", false, out var result))
187187
return result;
188188
return null;
189189
}
190190

191191
[Benchmark]
192192
public TestSmartEnum SmartEnum_TryFromName_Ten()
193193
{
194-
if(TestSmartEnum.TryFromName("Ten", false, out var result))
194+
if (TestSmartEnum.TryFromName("Ten", false, out var result))
195195
return result;
196196
return null;
197197
}
198-
198+
199199
[Benchmark]
200200
public TestSmartEnum SmartEnum_TryFromName_Invalid()
201201
{
202-
if(TestSmartEnum.TryFromName("Invalid", false, out var result))
202+
if (TestSmartEnum.TryFromName("Invalid", false, out var result))
203203
return result;
204204
return null;
205205
}
206206

207207
[Benchmark]
208208
public TestSmartEnum SmartEnum_TryFromName_one_IgnoreCase()
209209
{
210-
if(TestSmartEnum.TryFromName("one", true, out var result))
210+
if (TestSmartEnum.TryFromName("one", true, out var result))
211211
return result;
212212
return null;
213213
}
214214

215215
[Benchmark]
216216
public TestSmartEnum SmartEnum_TryFromName_ten_IgnoreCase()
217217
{
218-
if(TestSmartEnum.TryFromName("ten", true, out var result))
218+
if (TestSmartEnum.TryFromName("ten", true, out var result))
219219
return result;
220220
return null;
221221
}
222-
222+
223223
[Benchmark]
224224
public TestSmartEnum SmartEnum_TryFromName_Invalid_IgnoreCase()
225225
{
226-
if(TestSmartEnum.TryFromName("Invalid", true, out var result))
226+
if (TestSmartEnum.TryFromName("Invalid", true, out var result))
227227
return result;
228228
return null;
229-
}
229+
}
230230

231231
}
232232
}

‎benchmarks/SmartEnum.Benchmarks/FromValueBenchmarks.cs

+5-6
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,6 @@ namespace Ardalis.SmartEnum.Benchmarks
22
{
33
using System;
44
using BenchmarkDotNet.Attributes;
5-
using EnumsNET;
65

76
[Config(typeof(Config))]
87
public class FromValueBenchmarks
@@ -23,7 +22,7 @@ public TestEnum Enum_FromValue_Invalid()
2322
{
2423
return (TestEnum)1_000;
2524
}
26-
catch(Exception)
25+
catch (Exception)
2726
{
2827
return TestEnum.One;
2928
}
@@ -45,7 +44,7 @@ public TestSmartEnum SmartEnum_FromValue_Invalid()
4544
{
4645
return TestSmartEnum.FromValue(1_000);
4746
}
48-
catch(SmartEnumNotFoundException)
47+
catch (SmartEnumNotFoundException)
4948
{
5049
return null;
5150
}
@@ -54,23 +53,23 @@ public TestSmartEnum SmartEnum_FromValue_Invalid()
5453
[Benchmark]
5554
public TestSmartEnum SmartEnum_TryFromValue_1()
5655
{
57-
if(TestSmartEnum.TryFromValue(1, out var result))
56+
if (TestSmartEnum.TryFromValue(1, out var result))
5857
return result;
5958
return null;
6059
}
6160

6261
[Benchmark]
6362
public TestSmartEnum SmartEnum_TryFromValue_10()
6463
{
65-
if(TestSmartEnum.TryFromValue(10, out var result))
64+
if (TestSmartEnum.TryFromValue(10, out var result))
6665
return result;
6766
return null;
6867
}
6968

7069
[Benchmark]
7170
public TestSmartEnum SmartEnum_TryFromValue_Invalid()
7271
{
73-
if(TestSmartEnum.TryFromValue(1_000, out var result))
72+
if (TestSmartEnum.TryFromValue(1_000, out var result))
7473
return result;
7574
return null;
7675
}

‎benchmarks/SmartEnum.Benchmarks/Program.cs

+1-3
Original file line numberDiff line numberDiff line change
@@ -1,10 +1,8 @@
11
namespace Ardalis.SmartEnum.Benchmarks
22
{
3-
using System;
4-
using BenchmarkDotNet.Attributes;
53
using BenchmarkDotNet.Running;
64

7-
public class Program
5+
public static class Program
86
{
97
public static void Main(string[] args)
108
{

0 commit comments

Comments
 (0)