Jon Bock - Development Tech Blog

Lets look at some new features recently release with the C# 7.2 minor releases, I will explain what it was trying to solve and how.

A bit of background, with structs in C#, its possible to expose public properties as well as setting private properties, the example below shows its structure:-

public struct Document
{
public string Title { get; set; }
public string Author { get; set; }

public Document( string title, string author )
{
Title = title;
Author = author;
}

public void ChangeDocument(Document newDoc){
this = newDoc;
}
}

 So from this we can see that it causes the struct to be in a mutable state whereby we allow the public properties to be modified using the "this" key.

Moving for a more immutable solution we can leverage the new C# 7.2 feature and decorate the struct with readonly.

public readonly struct Document
{
public string Title { get; set; }
public string Author { get; set; }

public Document( string title, string author )
{
Title = title;
Author = author;
}

public void ChangeDocument(Document newDoc){
this = newDoc;
}
}

 This will cause a compile error with the this keyword as a result.

The code can then be shortened to refactor towards immutability as follows:-

public readonly struct Document
{
public string Title { get; set; }
public string Author { get; set; }

public Document (string title, string author)
{
Title = title;
Author = author;
}
}

 

So in the usage in the code, it can be updated from:-

var doc = new Document();
doc.Title = "SomeTitle";
doc.Author = "SomeAuthor";

to:-

var doc = new Document
{
Title = "SomeTitle",
Author = "SomeAuthor"
}

 

So with this new change, it encourages developers to program with immutability in mind and even though the default parameterless constructor is still available, readonly will cause a compile time error.

 

Here are the main differences everyone should know with your Http Verbs.

HTTP POST

Should be used when sending data to the server for newly created resources.

Example:-

POST /test/create HTTP/1.1
Host: jonbock.com
name1=value1&name2=value2

Response:-

• 201 (Created)
• 200 Ok
• 204 No Content

Ensure that POST

• Are not cached on the client or server side, each call will result in a attempt to create the resource
• Requests have no restrictions on data length

 

 

HTTP PUT

HTTP PUTs should be idempotent when used to create/update a resource, this means that each call should result in the same result occurring. The main difference between PUT and POST is that POST could result in side effects when called multiple times.

Example:-

• HTTP PUT http://www.appdomain.com/users/123

Response:-

• 201 (Created)
• 200 Ok
• 204 No content

 

HTTP PATCH

HTTP PATCH is used to update partial entity, it is usually used to send one or more changes to the server to be applied.

Example:-

HTTP PATCH /users/1

[
     { “op”: “replace”, “path”: “/email”, “value”: “[email protected]” }
]

Response:-

• 204 No content

 

One of the most important aspects in refactoring the most effective way is looking out for Primitive obsession.

What is it?

• The usage of primitive types instead of utilising small objects to represent data.
• Use of constants for the setting of information such as role=1
• Overuse of primitive types can make extending functionality more complicated and introduce more tech debt.

 

Why is this a problem?

Primitive obsession can come about from programming laziness and short cutting. If I want to store a title of a book in my class, then why not just use a string? Its much easier than creating a new object?

As you add more properties to the class, then things start to introduce more noise and the class become larger and harder to read.

 

How to treat this smell?

With lots of primitive types being introduced to the class one way to try and resolve this is to try to group them into logical groups in their own class. Examples of grouping can be something like functionality, behaviour or domain.

Code will become more flexible than using lots of primitive types, and creates a better understanding and organisation of code. It also makes it easier to find duplicated code when they are grouped into the same area of the code base.