Gamasutra is part of the Informa Tech Division of Informa PLC

This site is operated by a business or businesses owned by Informa PLC and all copyright resides with them. Informa PLC's registered office is 5 Howick Place, London SW1P 1WG. Registered in England and Wales. Number 8860726.


Gamasutra: The Art & Business of Making Gamesspacer
View All     RSS
September 24, 2020
arrowPress Releases







If you enjoy reading this site, you might also want to check out these UBM Tech sites:


 

Expression-Bodied Members to Reduce Your Code Verbosity

by Ruben Torres Bonet on 08/03/20 11:00:00 am   Expert Blogs

2 comments Share on Twitter    RSS

The following blog post, unless otherwise noted, was written by a member of Gamasutra’s community.
The thoughts and opinions expressed are those of the writer and not Gamasutra or its parent company.

 

[Visit the original blog post at Unity C#: Expression-Bodied Members to Reduce Your Code Verbosity]

Continuing with our Modern C# for Unity Game Development series, today I'm going to show you how to reduce the verbosity of your code with C# Expression-Bodied Members.

Note: this might upset some verbosity lovers out there ðŸ˜Â

Table of Contents

What's Wrong With This Damn Code?

Level Up With Unity C# Expression-Bodied Members

What's Next?

What's Wrong With This Damn Code?

Imagine you want to keep your player data synchronized with a server.

(Such a rare scenario, right?)

So you create your user manager class that does a GET request to update some fields.

Basically, you ask your backend for information on the a player ID. With that new information, you update your UI, gameplay elements and so on.

Here's a simplified code snippet that does this update:

public class UserDataProvider
{
  private string UrlUserInfo
  {
    get { return $"https://mygame.api/user/{_userData.userId}"; }
  }
  UserDataProvider(string userId)
  {
    _userData = new UserData(userId); 
  }
  void Start()
  {
    CoroutineManager.StartCoroutine(RefreshUserInfo()); 
  }
  IEnumerator RefreshUserInfo()
  {
    var request = UnityWebRequest.Get(UrlUserInfo);
    yield return request.SendWebRequest();
    _userData.name = ParseJson(request.downloadHandler.text, "name");
    // ...
  }
}

So, what's the problem with that?

You see, verbosity is my problem.

Sure, it looks quite normal if you're used to it... (I got pretty used to this code-writing style myself).

However, there's BIG room for improvement...

And today, we will be concerned with two questions:

  1. Do we really need so many curly braces?
  2. Do we really need these keywords, such as get and return?

A very standard-drivenverbosity-lover programmer will tell you that you need all of it.

But me, as a programmer who reads thousands of line of code per dayI'll buy into anything that:

  • Reduces the amount of time I spend reading code,
  • simplifies the code that I read...
  • so that I can use my time more efficiently.

And today I'm showing you the tool that will let you achieve all of this.

Level Up With Unity C# Expression-Bodied Members

Expression-bodied members is just one of these fancy terms that are easier to understand by reading code than by trying to decipher its name.

Put simply: this C# feature lets you remove verbosity when dealing with single expressions.

That means:

  • If your getter is a single expression, you can simplify it.
  • If your constructor is a single expression, you can simplify it.
  • If your function is a single expression, you can simplify it.
  • And a few more cases alike.

We gain this simplicity by skipping certain language elements (such as curly braces) and introducing the => operator.

No worries, reading actual code will make it much easier to understand.

Remember that getter and the functions?

Well, have a second look now:

private string UrlUserInfo => $"http://mygame.api/user/{_userData.userId}";
UserDataProvider(string userId) => _userData = new UserData(userId);
void Start() => StartCoroutine(RefreshUserInfo());

By using expression-bodied members I simplified my code so that...

  • The getter is now single line instead of 4 or even 7.
  • The constructor is now 1 line instead of 4
  • The Start function is now a single line instead of 4.

We got rid of curly braces... and the return + get keywords.

And I could go on with more examples, but you get the idea.

You can apply this technique as well to finalizers (destructors) and setters.

Here's one last example before I go:

private UserData _userData;
public UserData MyUserData
{
  get => _userData;
  set => _userData = value ?? _userData;
}

Neat!

What's Next?

If you missed any of my other posts on Modern C# for Unity game development, you can quickly catch up here.

And if you're wondering what else you can learn today to substantially improve your game, have a look at my tutorial on improving your game memory and loading times.

Alright, talk to you soon!

~Ruben


Related Jobs

Disbelief
Disbelief — Cambridge, Massachusetts, United States
[09.24.20]

Programmer
Phantasma Labs
Phantasma Labs — Berlin, Germany
[09.23.20]

Senior Software Engineer - Unreal Engine specialized in networking
Square Enix Co., Ltd.
Square Enix Co., Ltd. — Tokyo, Japan
[09.23.20]

Experienced Game Developer
Deep Silver Volition
Deep Silver Volition — Champaign, Illinois, United States
[09.17.20]

Senior Engine Programmer





Loading Comments

loader image