Refactoring for C# developers

Question 1

What is refactoring?

Answer 1

Changes to the internal structure of a software to make it easy to understand and modify.

Question 2

What does refactoring should NOT affect?

Answer 2

The observable behavior of the software.

Question 3

What happens if we don’t refactor often?

Answer 3

The software might get too complex to change.

Question 4

When to refactor?

Answer 4

After making the unit test pass (part of tdd);
As part of fixing a bug;
As part of creating a new feature;

Question 5

When not to refactor?

Answer 5

When current code does not work;
Massive technical debt (not developer’s call);
Imminent deadline;

Question 6

What does martin fowler says about refactoring?

Answer 6

Othen than when you’re very close to a deadline… you should not put off refactoring because you haven’t time.

Question 7

Does the boy scout rule apply in refactorings?

Answer 7

yes.

Question 8

What are the four steps of refactoring?

Answer 8

Commit (or restore) current working code;
Verify existing behavior (ideally with automated tests);
Apply a refactoring;
Confirm original behavior has been preserved.

Question 9

What is characterization tests and when they are most useful?

Answer 9

Characterization tests asserts the current behavior of the software (even without knowing if it is correct). Most useful for legacy software which does not have unit tests.

Question 10

What are the four steps of characterization tests?

Answer 10

Write tests you know will fail;
Get the output of the test;
Update the test to assert the current behavior;
Run the test again; should pass;

Question 11

What to refactor to achieve a cleaner code base?

Answer 11

remove duplication;
improve naming;
break up large code elements;
reduce coupling;
reduce  complexity;
split responsability (SRP);

Question 12

what is a code smell?

Answer 12

surface indication that usually correspond to a deeper problem in the system.

Question 13

What is the “Principle of Least Astonishment”?

Answer 13

Do what users expect;
Be simple;
Be clear;
!!!Be consistent!!!;

Question 14

What are the five classifications of code smells?

Answer 14

Bloaters, object-orientation abusers, change preventers, dispensables and couplers.

Question 15

What is a Bloater?

Answer 15

More code than it is actually necessary.

Question 16

What is a object-oriented abuser?

Answer 16

Disrupt the value provided by the object-oriented languages.

Question 17

What is a change preventer?

Answer 17

Any change requires touching many parts of the system.

Question 18

What is a dispensable?

Answer 18

Provide little or no value.

Question 19

What is a coupler?

Answer 19

Excessive coupling… preventing isolate changes to the system.

Question 20

What is a obfuscator?

Answer 20

Impede clear communication. Make harder to understand the code.

Question 21

What is non-nullable reference type? When was it introduced?

Answer 21

Forces an object to always have a reference, so not null. Introduced on c# 8.

Question 22

Whic .net version has C# 8 by default?

Answer 22

.net core 3

Question 23

how to enable nullable via compiler directive?

Answer 23

#nullable enable
#nullable disable

Question 24

How to enable nullable via csproj?

Answer 24

tag nullable enable nullable

Question 25

How to enable treat warning as errors for nullable errors?

Answer 25

adding CS8600 to project config.

Question 26

How to change the design intent to allow a nullable for a specific var (even when the whole project is not allowing it)?

Answer 26

via ?

string? message = null;

Question 27

What is the null-forgiving operator? When use it?

Answer 27

Is an operator that says that the programmer know that the given message!.Length will never be null. Use it when the compiler gives false positives (e.g when using reflection or during unit tests).

Question 28

In which situations the nullable compiler checking won’t be applied (even when it is enabled in the project)?

Answer 28

• when reflection is used;
• Calling code that has this feature disabled;
• When creating libs you should consider null checking stuff.