6 trendy C# options for cleaner Unity code

Since C# 7.0, many code enhancements that assist us write much less code have been added to the language. This tutorial will concentrate on six new options that may assist us write extra concise and readable code and the way we are able to use these options on our C# for Unity.

These are the tutorial sections:

Conditions

The next conditions are required to comply with together with this tutorial:

• Primary information of Unity
• Earlier expertise writing C# scripts in Unity

Organising our Unity mission

First, we have to create our Unity mission. For this tutorial, we’ll use the model 2021.3.4f1, which, in the meanwhile I’m writing, is the most recent LTS Unity model.

On the mission templates record, select 2D(core) (the best of all), give it a reputation, and click on the Create mission button.

With the mission began, create a folder referred to as Scripts contained in the Property folder. We’ll use them to maintain our mission organized through the tutorial.

Tutorial construction

For every pattern of learn how to use the brand new C# function, we are going to first have a look at the way it was executed earlier than after which how we may write much less and extra readable code with the brand new function.

The lessons under are simply stubs which can be used on all samples all through the tutorial. You possibly can add them to a script contained in the Scripts folder:

// GAME MODE.
public enum GameMode
{
    TimeAttack,
    Survive,
    Factors
}

// ENEMIES.
public summary class Enemy
{
    public bool IsVisible { get; set; }
    public bool HasArmor { get; set; }
}
 
public class Minion : Enemy { }
public class Troll : Enemy { }
public class Vampire : Enemy { }

public class Zombie : Enemy { }


// WEAPONS.
public summary class Weapon { }
public class Stake : Weapon { }
public class Shotgun : Weapon { }

C# options help in Unity

In C# variations 8 and 9, a number of new options had been added to the language. You possibly can learn the total options record for every model within the hyperlinks under:

C# 8 and 9 options in Unity: What’s lacking?

Unity help for C# 8 has began on model 2020.2 and C# 9 has began on model 2021.2.

Remember that not each C# 8 and 9 function is supported by Unity, like:

• default interface strategies
• indices and ranges
• asynchronous streams
• asynchronous disposable
• suppress emitting locals init flag
• covariant return varieties
• module initializers
• extensible calling conventions for unmanaged operate pointers
• init solely setters

Most of those unsupported options are utilized in very particular situations, like extensible calling conventions for unmanaged operate pointers, and a few aren’t, like indices and ranges.

Due to this, options like indices and ranges and init solely setters will seemingly be supported in future variations of Unity. Nevertheless, the prospect of an unsupported function for a really particular situation gaining Unity help sooner or later is smaller than a function like indices and ranges.

Perhaps yow will discover some workarounds to make use of these unsupported options in Unity, however I discourage you from doing this as a result of Unity is a cross-platform sport engine. A workaround in a brand new function could lead on you to issues fairly laborious to know, debug, and resolve.

Thankfully, Unity helps a number of the extra widespread patterns and expressions from C# 8 and 9. Let’s assessment a number of the most useful ones under and see how they will allow us to put in writing cleaner code.

Swap expression

The swap expression can dramatically simplify and scale back the LOC (Strains Of Code) to make a swap, as a result of we are able to keep away from a bunch of boilerplate code, just like the case and return statements.

Doc tip: the swap expression gives for switch-like semantics in an expression context. It gives a concise syntax when the swap arms produce a worth.

Usually, a swap assertion produces a worth in every of its case blocks. Swap expressions allow you to make use of extra concise expression syntax. There are fewer repetitive case and break key phrases and fewer curly braces.

Earlier than

public string GetModeTitleOld(GameMode mode)
{
    swap (mode)
    {
        case GameMode.Factors:
            return "Factors mode";

        case GameMode.Survive:
            return "Survive mode";

        case GameMode.TimeAttack:
            return "Time Assault mode";

        default:
            return "Unsupported sport mode";
    }
}

After

public string GetModeTitleNew(GameMode mode)
{
    return mode swap
    {
        GameMode.Factors => "Factors mode",
        GameMode.Survive => "Survive mode",
        GameMode.TimeAttack => "Time Assault mode",
        _ => "Unsupported sport mode",
    };
}

Property sample

The property sample allows you to match on properties of the item examined in a swap expression.

As you’ll be able to see within the pattern under, utilizing a property sample, we are able to rework a collection of if statements right into a easy record of properties that the item on the swap assertion ought to match.

The _ => has the identical which means because the default on a basic swap.

Doc tip: a property sample matches an expression when an expression result’s non-null and each nested sample matches the corresponding property or discipline of the expression consequence.

Earlier than

public float CalculateDamageOld(Enemy enemy)
{
    if (enemy.IsVisible)
        return enemy.HasArmor ? 1 : 2;

    return 0;
}

After

public static float CalculateDamageNew(Enemy enemy) => enemy swap
{
    { IsVisible: true, HasArmor: true } => 1,
    { IsVisible: true, HasArmor: false } => 2,
    _ => 0
};

Sort sample

We will use sort patterns to examine if the runtime sort of an expression is appropriate with a given sort.

The kind sample is nearly the identical logic as a property sample however is now utilized in a context of an object sort. We will rework a collection of if statements that examine an object sort into an inventory of varieties that the item on the swap assertion ought to match.

Earlier than

public static float GetEnemyStrengthOld(Enemy enemy)
{
    if (enemy is Minion)
        return 1;

    if (enemy is Troll)
        return 2;

    if (enemy is Vampire)
        return 3;

    if (enemy == null)
        throw new ArgumentNullException(nameof(enemy));

    throw new ArgumentException("Unknown enemy", nameof(enemy));
}

After

public static float GetEnemyStrengthNew(Enemy enemy) => enemy swap
{
    Minion => 1,
    Troll => 2,
    Vampire => 3,
    null => throw new ArgumentNullException(nameof(enemy)),
    _ => throw new ArgumentException("Unknown enemy", nameof(enemy)),
};

Utilizing the sort sample, we go from 16 strains of code to solely 8 which have the identical consequence and are fairly clear to learn and perceive.

Fixed sample

A continuing sample can be utilized to check if an expression consequence equals a specified fixed.

In all probability the best sample match, it simply matches a continuing worth — for example, a string — after which returns the consequence.

Earlier than

public Enemy CreateEnemyByNameOld(string identify)
{
    if(identify == null)
        throw new ArgumentNullException(nameof(identify));

    if (identify.Equals("Minion"))
        return new Minion();

    if (identify.Equals("Troll"))
        return new Troll();

    if (identify.Equals("Vampire"))
        return new Vampire();

    throw new ArgumentException($"Unknown enemy: {identify}", nameof(identify));
}

After

public Enemy CreateEnemyByNameNew(string identify) => identify swap
{
    "Minion" => new Minion(),
    "Troll" => new Troll(),
    "Vampire" => new Vampire(),
    null => throw new ArgumentNullException(nameof(identify)),
    _ => throw new ArgumentException($"Unknown enemy: {identify}", nameof(identify)),
};

A continuing sample can be utilized with any fixed expression, like int, float, char, string, bool, and enum.

Relational sample

A relational sample will examine an expression consequence with a continuing.

This one may appear essentially the most advanced sample match, however at its core it’s not that sophisticated. What we are able to do with a Relational Sample is straight use logical operators as <, >, <=, or >= to judge the item after which present a consequence for the swap.

Doc tip: the right-hand a part of a relational sample should be a continuing expression.

Earlier than

public string GetEnemyEnergyMessageOld(float power)

After

public string GetEnemyEnergyMessageNew(float power) => power swap
{
    < 0 or > 1 => throw new ArgumentException("Vitality ought to be between 0.0 and 1.0", nameof(power)),
    >= 1 => "Wholesome",
    > .5f => "Injured",
    _ => "Very harm"
};

Any of the relational operators <, >, <=, or >= can be utilized on a relational sample.

Logical sample

We will use the not, and, and or sample combinators to create logical expressions.

That is like an extension of the relational sample the place you’ll be able to mix the logical operators not, and, and or to create a extra advanced and elaborate sample match.

Doc tip: you utilize the not, and, and or sample combinators to create the next logical patterns:

• Negation not sample that matches an expression when the negated sample doesn’t match the expression
• Conjunctive and sample that matches an expression when each patterns match the expression
• Disjunctive or sample that matches an expression when both sample matches the expression

Earlier than

public float CalculateEnergyLossByStakeOld(Enemy enemy)
{
    if (enemy == null)
        throw new ArgumentNullException(nameof(enemy));

    if (enemy isn't Vampire)
        return .1f;

    return 1f;
}

After

public float CalculateEnergyLossByStakeNew(Enemy enemy) => enemy swap
{
    null => throw new ArgumentNullException(nameof(enemy)),
    not Vampire => .1f,
    _ => 1f
};

Conclusion

On this tutorial, we’ve discovered learn how to use the swap expression, property sample, sort sample, fixed sample, relational sample, and logical sample to put in writing much less and extra trendy C# code on Unity.

Hopefully, you should utilize a few of these in your subsequent mission to spare your self time whereas writing cleaner code.