{"id":357,"date":"2022-01-05T10:41:31","date_gmt":"2022-01-05T03:41:31","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=357"},"modified":"2022-06-03T13:40:46","modified_gmt":"2022-06-03T06:40:46","slug":"csharp-expression-bodied-members","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-tutorial\/csharp-expression-bodied-members\/","title":{"rendered":"C# Expression-Bodied Members"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn about expression-bodied members to make your code concise and more readable.<\/p>\n\n\n\n

Introduction to expression-bodied members<\/h2>\n\n\n\n

C# introduced the expression body definition for methods and read-only properties in version 6 and expanded it to properties<\/a>, constructors<\/a>, finalizers, and indexers<\/a> in version 7.<\/p>\n\n\n\n

An expression body definition has the following syntax:<\/p>\n\n\n

member => expression;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this syntax:<\/p>\n\n\n\n
  • The member<\/code> can be a method, a property, a constructor, a finalizer, or an indexer.<\/li>
  • The expression<\/code> is any valid expression.<\/li><\/ul>\n\n\n\n
    The purpose of the expression body definition is to make the code concise and more readable.<\/p>\n\n\n\n
    Methods<\/h2>\n\n\n\n
    If a method has a single expression that returns a value whose type matches the method’s return type, you can use an expression body definition.<\/p>\n\n\n\n
    For example, the following example defines the Person<\/code> class:<\/p>\n\n\n
    \/\/ Person.cs<\/span>\nclass<\/span> Person<\/span>\n{\n    public<\/span> string<\/span> FirstName { get<\/span>; set<\/span>; }\n    \n    public<\/span> string<\/span> LastName { get<\/span>; set<\/span>; }   \n\n    public<\/span> byte<\/span> Age { get<\/span>; set<\/span>; }\n\n    public<\/span> string<\/span> GetFullName<\/span>(<\/span>)<\/span>\n    {\n        return<\/span> $\"{FirstName}<\/span> {LastName}<\/span>\"<\/span>;\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this Person<\/code> class, the GetFullName()<\/code> method returns a string that matches the return type of the method:<\/p>\n\n\n
    public<\/span> string<\/span> GetFullName<\/span>(<\/span>)<\/span>\n{\n    return<\/span> $\"{FirstName}<\/span> {LastName}<\/span>\"<\/span>;\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Therefore, you can use an expression-bodied method as follows:<\/p>\n\n\n
    public<\/span> string<\/span> GetFullName<\/span>(<\/span>)<\/span> => $\"{FirstName}<\/span> {LastName}<\/span>\"<\/span>;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    And here’s the new Person<\/code> class:<\/p>\n\n\n
    \/\/ Person.cs<\/span>\nclass<\/span> Person<\/span>\n{\n    public<\/span> string<\/span> FirstName { get<\/span>; set<\/span>; }\n\n    public<\/span> string<\/span> LastName { get<\/span>; set<\/span>; }\n\n    public<\/span> byte<\/span> Age { get<\/span>; set<\/span>; }\n\n    public<\/span> string<\/span> GetFullName<\/span>(<\/span>)<\/span> => $\"{FirstName}<\/span> {LastName}<\/span>\"<\/span>;\n \n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Read-only properties<\/h2>\n\n\n\n
    Starting with C# 6, you can use expression body definition for a read-only property. For example, the following adds the CanVote<\/code> read-only property to the Person<\/code> class:<\/p>\n\n\n
    \/\/ Person.cs<\/span>\nclass<\/span> Person<\/span>\n{\n    public<\/span> string<\/span> FirstName { get<\/span>; set<\/span>; }\n\n    public<\/span> string<\/span> LastName { get<\/span>; set<\/span>; }\n\n    public<\/span> byte<\/span> Age { get<\/span>; set<\/span>; }\n\n    public<\/span> bool<\/span> CanVote\n    {\n        get<\/span>\n        {\n            return<\/span> Age >= 16<\/span> && Age <= 65<\/span>;\n        }\n    }\n\n    public<\/span> string<\/span> GetFullName<\/span>(<\/span>)<\/span> => $\"{FirstName}<\/span> {LastName}<\/span>\"<\/span>;\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Since the CanVote<\/code> property is read-only, you can use an expression body definition like this:<\/p>\n\n\n
    public<\/span> bool<\/span> CanVote => Age >= 16<\/span> && Age <= 65<\/span>;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Here’s the updated Person<\/code> class:<\/p>\n\n\n
    \/\/ Person.cs<\/span>\nclass<\/span> Person<\/span>\n{\n    public<\/span> string<\/span> FirstName { get<\/span>; set<\/span>; }\n\n    public<\/span> string<\/span> LastName { get<\/span>; set<\/span>; }\n\n    public<\/span> byte<\/span> Age { get<\/span>; set<\/span>; }\n\n    public<\/span> bool<\/span> CanVote => Age >= 16<\/span> && Age <= 65<\/span>;\n\n    public<\/span> string<\/span> GetFullName<\/span>(<\/span>)<\/span> => $\"{FirstName}<\/span> {LastName}<\/span>\"<\/span>;\n  \n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Constructors<\/h2>\n\n\n\n
    The following example defines the Skill<\/code> class whose constructor has an expression that assigns the skill name to the Name<\/code> property:<\/p>\n\n\n
    class<\/span> Skill<\/span>\n{\n    public<\/span> string<\/span> Name { get<\/span>; set<\/span>; }\n\n    public<\/span> Skill<\/span>(string<\/span> name<\/span>)<\/span>\n    {\n        Name = name;\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Hence, you can use the expression body definition for the Skill constructor as follows:<\/p>\n\n\n
    class<\/span> Skill<\/span>\n{\n    public<\/span> string<\/span> Name { get<\/span>; set<\/span>; }\n    public<\/span> Skill<\/span>(string<\/span> name<\/span>)<\/span> => Name = name;\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Indexers<\/h2>\n\n\n\n
    The following example defines the Matrix class that uses an index to access an element at a row and column:<\/p>\n\n\n
    \/\/ Matrix.cs<\/span>\nclass<\/span> Matrix<\/span>\n{\n    private<\/span> double<\/span>[,] data;\n    public<\/span> Matrix<\/span>(int<\/span> row, int<\/span> column<\/span>)<\/span>\n    {\n        data = new<\/span> double<\/span>[row, column];\n    }\n\n    public<\/span> double<\/span> this<\/span>[int<\/span> row, int<\/span> column]\n    {\n        get<\/span> { return<\/span> data[row, column]; }\n        set<\/span> { data[row, column] = value<\/span>; }\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    In this example, the get<\/code> and set<\/code> accessors of the indexer have only one expression. So you can use an expression body definition as follows:<\/p>\n\n\n
    \/\/ Matrix.cs<\/span>\nclass<\/span> Matrix<\/span>\n{\n    private<\/span> double<\/span>[,] data;\n\n    public<\/span> Matrix<\/span>(int<\/span> row, int<\/span> column<\/span>)<\/span> => data = new<\/span> double<\/span>[row, column];\n\n    public<\/span> double<\/span> this<\/span>[int<\/span> row, int<\/span> column]\n    {\n        get<\/span> => data[row, column];\n        set<\/span> => data[row, column] = value<\/span>;\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
    Summary<\/h2>\n\n\n\n
    • Use the C# expression-bodied members to make the code concise and more readable.<\/li><\/ul>\n
      \n\t
      \n\t\t
      Was this tutorial helpful ?<\/div>\n\t\t
      \n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t Yes <\/span>\n\t\t\t<\/button>\n\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t<\/path>\n\t\t\t\t<\/svg>\n\t\t\t\t No <\/span>\n\t\t\t<\/button>\n\t\t<\/div>\n\t<\/header>\n\n\t
      \n\t\t
      \n\t\t\t
      <\/div>\n\t\t\t\n\t\t\t