האם סי-שארפ נהייתה יותר פשוטה?

CSharp 9.0

סי-שארפ שפה מאוד יציבה אך היא מוכיחה שוב ושוב בגמישותה.

Top-level statements

כל פעם שיצרנו פרוקייט חדש ב-C# הוא יצר לנו קובץ בשם Main.cs עם המחלקה הבאה:

using System;

namespace MyNameSpace
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }
    }
}

כדי לכתוב תכנית פשוטה היינו צריכים:

חייבים לייבא את System.
להשתמש ב-Namespace.
ליצור מחלקה - Program.
ליצור פונקציית Main.

זה קוד שאנחנו קוראים לו Boilerplate code - קוד משוכפל.
הוא הכרחי, הוא קיים, והוא קיים בכל כך הרבה קבצים ופרוייקטים אך אי אפשר להוריד אותו ללא תמיכת השפה.

Boilerplate code

קוד שהוא Boilerplate בדרך כלל אפילו לא נקרא אלה רק קיים שם כדי להוכיח את קיומו.
כל משפטי ה-using הם כאלו.
הצהרה על מחלקת Program היא כזו.

ב-C# נלחמים בתופעה הזו החל מגרסאותיה הראשונות:
התכונה הראשונה שבאמת נלחמה ב-boilerplate אלה הם התכונות - properties.

במקום לכתוב את הדבר הבא:

public class Person
{
    private string mName;
    
    public string GetName()
    {
        return mName;
    }

    public void SetName(string name)
    {
        mName = name;  
    }
}

הקומפיילר יודע לייצר לנו קוד כזה ע”י שימוש ב-properties:

public class Person
{
   public string Name { get; set;}
}

מאחורי הקלעים הוא עדיין יוצר שני מתודות ל-get ו-set וfield אבל הקומפיילר עושה את זה עבורנו.

Records

מאפיינים גרמו לנו לכתוב הרבה מחלקות עם מידע בלבד - מחלקות כאלו נקראות מודלים - Models.

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
    public int Age { get; set; }
}

שזה לשם עצמו יצר boilerplate.

כדי לתקן את זה יצרו מחלקות חדשות בשם records:

1	public record Person(string FirstName, string LastName, int Age);

כעת ניתן בשורה אחת ליצור מודלים עם Type משלנו.
ליצור Type בהתאמה אישית עוזרת לנו ליצור ספריות יותר ברורות.
ניתן היה להשתמש ב-ValueTuple<string,string,int> אך זה אף פעם לא נוח כי אין לנו שמות לפונקציות ולמידע של המחלקה.

איך סי-שארפ לקחה את זה מקוטלין

Kotlin הביאה איתה חידושים רבים וכמוני רואים בה כמחליפת Java בחלק מהטכנולוגיות.
זה לא נכון לומר את זה לכל הטכנולוגיות אך למשל ל-Android ניתן כבר להשתמש ב-Kotlin.

Kotlin הקדימה את סי-שארפ עם Records, שם זה נקרא Data Classes.

ניתן לקרוא על זה כאן:
https://kotlinlang.org/docs/data-classes.html

זה נראה כך:

1	data class User(val name: String, val age: Int)

הקסם של הקומפיילר

הקומפיילר של C# מייצר לנו קוד רב.

אם לקחת את דוגמת ה-Record השורה למעלה מייצרת לנו את הקוד הבא מאחורי הקלעים:

RecordUnderTheHood

// Decompiled with JetBrains decompiler
// Type: ConsoleApp1.Person
// Assembly: ConsoleApp1, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
// MVID: CCF9A9D0-5DFB-45DD-9F9B-3F9854B60322
// Assembly location: C:\Ilya\Programming\Projects\ConsoleApp1\ConsoleApp1\bin\Debug\net7.0\ConsoleApp1.dll
// Compiler-generated code is shown

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.Text;

namespace ConsoleApp1
{
  [NullableContext(1)]
  [Nullable(0)]
  public class Person : 
  /*[Nullable(0)]*/
  IEquatable<Person>
  {
    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private readonly string \u003CName\u003Ek__BackingField;
    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private readonly int \u003CAge\u003Ek__BackingField;
    [CompilerGenerated]
    [DebuggerBrowsable(DebuggerBrowsableState.Never)]
    private readonly string \u003CStreet\u003Ek__BackingField;

    public Person(string Name, int Age, string Street)
    {
      this.\u003CName\u003Ek__BackingField = Name;
      this.\u003CAge\u003Ek__BackingField = Age;
      this.\u003CStreet\u003Ek__BackingField = Street;
      base.\u002Ector();
    }

    [CompilerGenerated]
    protected virtual Type EqualityContract
    {
      [CompilerGenerated] get
      {
        return typeof (Person);
      }
    }

    public string Name
    {
      [CompilerGenerated] get
      {
        return this.\u003CName\u003Ek__BackingField;
      }
      [CompilerGenerated] init
      {
        this.\u003CName\u003Ek__BackingField = value;
      }
    }

    public int Age
    {
      [CompilerGenerated] get
      {
        return this.\u003CAge\u003Ek__BackingField;
      }
      [CompilerGenerated] init
      {
        this.\u003CAge\u003Ek__BackingField = value;
      }
    }

    public string Street
    {
      [CompilerGenerated] get
      {
        return this.\u003CStreet\u003Ek__BackingField;
      }
      [CompilerGenerated] init
      {
        this.\u003CStreet\u003Ek__BackingField = value;
      }
    }

    [CompilerGenerated]
    public override string ToString()
    {
      StringBuilder builder = new StringBuilder();
      builder.Append(nameof (Person));
      builder.Append(" { ");
      if (this.PrintMembers(builder))
        builder.Append(' ');
      builder.Append('}');
      return builder.ToString();
    }

    [CompilerGenerated]
    protected virtual bool PrintMembers(StringBuilder builder)
    {
      RuntimeHelpers.EnsureSufficientExecutionStack();
      builder.Append("Name = ");
      builder.Append((object) this.Name);
      builder.Append(", Age = ");
      builder.Append(this.Age.ToString());
      builder.Append(", Street = ");
      builder.Append((object) this.Street);
      return true;
    }

    [NullableContext(2)]
    [CompilerGenerated]
    public static bool operator !=(Person left, Person right)
    {
      return !(left == right);
    }

    [NullableContext(2)]
    [CompilerGenerated]
    public static bool operator ==(Person left, Person right)
    {
      if ((object) left == (object) right)
        return true;
      return (object) left != null && left.Equals(right);
    }

    [CompilerGenerated]
    public override int GetHashCode()
    {
      return ((EqualityComparer<Type>.Default.GetHashCode(this.EqualityContract) * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.\u003CName\u003Ek__BackingField)) * -1521134295 + EqualityComparer<int>.Default.GetHashCode(this.\u003CAge\u003Ek__BackingField)) * -1521134295 + EqualityComparer<string>.Default.GetHashCode(this.\u003CStreet\u003Ek__BackingField);
    }

    [NullableContext(2)]
    [CompilerGenerated]
    public override bool Equals(object obj)
    {
      return this.Equals(obj as Person);
    }

    [NullableContext(2)]
    [CompilerGenerated]
    public virtual bool Equals(Person other)
    {
      if ((object) this == (object) other)
        return true;
      return (object) other != null && this.EqualityContract == other.EqualityContract && EqualityComparer<string>.Default.Equals(this.\u003CName\u003Ek__BackingField, other.\u003CName\u003Ek__BackingField) && EqualityComparer<int>.Default.Equals(this.\u003CAge\u003Ek__BackingField, other.\u003CAge\u003Ek__BackingField) && EqualityComparer<string>.Default.Equals(this.\u003CStreet\u003Ek__BackingField, other.\u003CStreet\u003Ek__BackingField);
    }

    [CompilerGenerated]
    public virtual Person \u003CClone\u003E\u0024()
    {
      return new Person(this);
    }

    [CompilerGenerated]
    protected Person(Person original)
    {
      base.\u002Ector();
      this.\u003CName\u003Ek__BackingField = original.\u003CName\u003Ek__BackingField;
      this.\u003CAge\u003Ek__BackingField = original.\u003CAge\u003Ek__BackingField;
      this.\u003CStreet\u003Ek__BackingField = original.\u003CStreet\u003Ek__BackingField;
    }

    [CompilerGenerated]
    public void Deconstruct(out string Name, out int Age, out string Street)
    {
      Name = this.Name;
      Age = this.Age;
      Street = this.Street;
    }
  }
}

כמה דברים חשובים שאנו רואים פה:

ToString

הקומפיילר מייצר לנו ToString לכל ה-Memberים.

1 2	Person p = new Person("Bob", "Bobson", 42); Console.WriteLine(p.ToString());

מודפס:

Person { FirstName = Bob, LastName = Bobson, Age = 42 }.

Equals ו- ==

העמסות חשובות כדי לבדוק האם שני אובייקטים הם שווים או אותם מופעים.

Person p2 = new ("Alice", "Alison", 37);
Person p3 = p;

Console.WriteLine(p == p2);
Console.WriteLine(p.Equals(p2));
Console.WriteLine(p == p3);

שימו לב שפה אנו משמיטים גם את סוג המחלקה כאשר אנו משתמשים ב-new.
פיצ’ר חדש של C# 9!

יודפס:

1
2
3

False
False
True

Deconstruct

לבצע פירוק לגורמים של המחלקה:

Person p = new ("Bob", "Bobson", 42);
(string FirstName, string LastName, _) = p;

Console.WriteLine(FirstName);
Console.WriteLine(LastName);

יודפס:

1 2	Bob Bobson

שימו לב שניתן בעזרת _ להשמיט פרמטרים שלא רוצים אותם!

החידושים של C# תמיד הכי מודרניים וכבר שני עשורים שהיא מובילה בתכונותיה ובטכנולוגיות שלה.
ניתן ליצור ממשקי משתמש דסקטופיים, לפתח משחקים, שרתים, APIים ועוד!

תודה על הקריאה :)