C# vs Java: תחביר, סביבת ריצה, Generics, LINQ ומה ללמוד

C# ו-Java הן קרובות משפחה. שתיהן שפות עם טיפוסים סטטיים, מונחות עצמים ועם garbage collector, בתחביר בסגנון C, שתיהן מתקמפלות ל-bytecode עבור מכונה וירטואלית, ושתיהן משמשות למערכות backend גדולות. C# יצאה ב-2002, בין השאר כתשובה של Microsoft ל-Java, ולאורך שני עשורים השתיים שאלו תכונות זו מזו (lambdas, generics, records, pattern matching). מפתח שמכיר אחת מהן יכול לקרוא את השנייה כמעט מיד.

ההבדלים שחשובים ביום-יום קטנים וספציפיים יותר. הדף הזה עובר עליהם עם קוד: קטעי C# שאפשר להריץ, ו-Java בבלוקים סטטיים להשוואה.

במבט מהיר

תחביר: כמעט אותו דבר

מחלקות, מתודות, if, for, while, switch, try/catch נקראים כמעט זהה. ההבדלים הנראים לעין הם מוסכמות שמות וכמה מילות מפתח: מתודות ב-C# הן PascalCase (ToUpper, WriteLine), מתודות ב-Java הן camelCase (toUpperCase, println); C# כותבת string ו-bool, ו-Java String ו-boolean; ירושה היא class Dog : Animal ב-C# ו-class Dog extends Animal ב-Java.

// Java
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Ana");
        names.add("Ben");
        for (String n : names) {
            System.out.println(n.toUpperCase());
        }
    }
}

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        var names = new List<string> { "Ana", "Ben" };
        foreach (string n in names)
        {
            Console.WriteLine(n.ToUpper());
        }
    }
}

פלט:

ANA
BEN

C# גם משווה מחרוזות לפי ערך עם ==, וזה מעלים את אחד הבאגים הקלאסיים של מתחילים ב-Java: ב-Java, == על שני אובייקטי String משווה הפניות, כך ששתי מחרוזות שוות שנבנו בזמן ריצה (נקראו מקלט, שורשרו) יכולות לצאת שונות בהשוואה.

מאפיינים במקום getters ו-setters

מחלקות Java חושפות מצב דרך מתודות getName() ו-setName(), שבדרך כלל נוצרות על ידי IDE או Lombok. ב-C# יש מאפיינים (properties): איברים שנקראים כמו שדות אבל מריצים קוד.

// Java
public class Product {
    private double price;
    public double getPrice() { return price; }
    public void setPrice(double price) {
        if (price < 0) throw new IllegalArgumentException("negative");
        this.price = price;
    }
}

using System;

class Product
{
    public string Name { get; set; }        // auto-property

    private decimal price;
    public decimal Price                     // property with validation
    {
        get { return price; }
        set
        {
            if (value < 0) throw new ArgumentException("Price cannot be negative");
            price = value;
        }
    }
}

class Program
{
    static void Main()
    {
        var p = new Product { Name = "Mug", Price = 8.50m };
        p.Price += 1.00m;                    // reads and writes like a field
        Console.WriteLine($"{p.Name}: {p.Price:F2}");
    }
}

פלט:

Mug: 9.50

ה-object initializer new Product { Name = ..., Price = ... } מציב מאפיינים מיד אחרי הבנייה. records של Java (Java 16) מכסים את המקרה של נתונים בלתי ניתנים לשינוי; גם ב-C# יש records (C# 9), ובנוסף מאפיינים לכל השאר.

טיפוסי ערך: structs

ב-Java, כל טיפוס שהמשתמש מגדיר הוא טיפוס הפניה שמאוחסן ב-heap; רק שמונת הטיפוסים הפרימיטיביים (int, double, ...) הם ערכים. C# מאפשרת להגדיר טיפוסי ערך משלכם עם struct. struct מועתק בהצבה ויכול לחיות בתוך מערכים ובתוך אובייקטים אחרים, בלי הקצאה נפרדת ב-heap.

using System;

struct Point
{
    public int X;
    public int Y;
    public Point(int x, int y) { X = x; Y = y; }
}

class Program
{
    static void Main()
    {
        var a = new Point(1, 2);
        var b = a;          // copies the whole value
        b.X = 99;
        Console.WriteLine($"a = ({a.X}, {a.Y})");
        Console.WriteLine($"b = ({b.X}, {b.Y})");

        var grid = new Point[1000]; // one block of 1000 points, not 1000 objects
        Console.WriteLine(grid.Length);
    }
}

פלט:

a = (1, 2)
b = (99, 2)
1000

זה חשוב במשחקים ובקוד נומרי, שבהם מיליוני אובייקטים קטנים היו מפעילים לחץ על ה-garbage collector. ראו structs.

Generics: נשמרים מול נמחקים

Java מוחקת את ארגומנטי הטיפוס הגנריים בזמן קומפילציה: בזמן ריצה List<Integer> הוא פשוט List, ו-List<int> אסור (מקבלים אובייקטי Integer עטופים). C# שומרת את ארגומנטי הטיפוס בזמן ריצה, כך ש-List<int> מאחסן ints גולמיים וקוד יכול לשאול מה זה T.

using System;
using System.Collections.Generic;

class Program
{
    static string Describe<T>(List<T> items)
    {
        return $"{items.Count} items of type {typeof(T).Name}";
    }

    static T Create<T>() where T : new()
    {
        return new T();     // impossible in Java: T is erased
    }

    static void Main()
    {
        Console.WriteLine(Describe(new List<int> { 1, 2, 3 }));
        Console.WriteLine(Describe(new List<string> { "a" }));

        var list = Create<List<decimal>>();
        Console.WriteLine(list.GetType().Name);
    }
}

פלט:

3 items of type Int32
1 items of type String
List`1

typeof(T) ו-new T() עובדים כי סביבת הריצה מכירה את T. ב-Java שניהם שגיאות קומפילציה, והעקיפה המקובלת היא להעביר אובייקט Class<T> מסביב.

LINQ מול streams

בשתי השפות יש API רציף לסינון ולהמרה של אוספים. ב-Java זה ה-Streams API (Java 8); ב-C# זה LINQ (C# 3), שיש לו גם תחביר שאילתות והוא עובד מול מסדי נתונים דרך Entity Framework.

// Java
List<String> expensive = products.stream()
    .filter(p -> p.getPrice() > 20)
    .sorted(Comparator.comparing(Product::getPrice))
    .map(Product::getName)
    .collect(Collectors.toList());

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        var products = new[]
        {
            new { Name = "Lamp", Price = 35m },
            new { Name = "Pen", Price = 2m },
            new { Name = "Chair", Price = 80m },
            new { Name = "Mug", Price = 9m }
        };

        var expensive = products
            .Where(p => p.Price > 20)
            .OrderBy(p => p.Price)
            .Select(p => p.Name)
            .ToList();
        Console.WriteLine(string.Join(", ", expensive));

        var total = products.Sum(p => p.Price);
        Console.WriteLine($"Total: {total}");
    }
}

פלט:

Lamp, Chair
Total: 126

הפעולות מקבילות אחת לאחת (filter היא Where, map היא Select, collect(toList()) היא ToList()), והגרסאות של C# לא צריכות stream() או collector. האובייקטים new { Name = ..., Price = ... } הם טיפוסים אנונימיים, שאין להם מקבילה ישירה ב-Java.

Async ומקביליות

C# הציגה את async/await ב-2012: מתודת async מחזירה Task, ו-await משהה אותה בלי לחסום thread. JavaScript, Python ו-Rust אימצו מאוחר יותר את אותן מילות מפתח. Java הלכה בדרך אחרת: שרשראות של CompletableFuture, ומאז Java 21, virtual threads שהופכים קוד חוסם רגיל לזול.

// C#
async Task<string> LoadAsync(HttpClient http, string url)
{
    string body = await http.GetStringAsync(url);
    return body.Substring(0, 100);
}

// Java 21 with virtual threads: plain blocking code on a cheap thread
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    executor.submit(() -> client.send(request, BodyHandlers.ofString()));
}

שתי הגישות מתרחבות להרבה בקשות במקביל. C# הופכת את האסינכרוניות לגלויה בחתימות המתודות; Java מסתירה אותה בסביבת הריצה.

חריגות, אופרטורים והבדלים קטנים יותר

• Checked exceptions. Java מכריחה מתודה להצהיר על חריגות מסוימות או לתפוס אותן (throws IOException). ב-C# אין checked exceptions בכלל.
• העמסת אופרטורים. C# מאפשרת לטיפוסים להגדיר +, ==, < וחבריהם, ולכן חשבון עם decimal ו-DateTime נקרא באופן טבעי. Java לא מאפשרת (BigDecimal.add).
• Virtual כברירת מחדל. ב-Java אפשר לדרוס מתודות אלא אם הן מסומנות final; ב-C# צריך לסמן מתודות virtual כדי שיהיה אפשר לדרוס אותן, והדריסה חייבת לכתוב override.
• Extension methods. C# יכולה להוסיף מתודות לטיפוסים קיימים ("text".IsPalindrome()); Java לא יכולה.
• Nullable value types. int? ב-C# הוא int שיכול להיות null; Java משתמשת ב-Integer העטוף.
• טיפוסים ללא סימן. ב-C# יש uint, ulong, ushort ו-byte ללא סימן; ה-byte של Java הוא עם סימן, ומלבד ה-char של 16 ביט אין בה טיפוסי מספרים שלמים ללא סימן.

אקוסיסטמה, משרות ומה ללמוד

האקוסיסטמה של Java גדולה יותר בעולם הקוד הפתוח בצד השרת: Spring, Kafka, Spark, Hadoop, Elasticsearch ורוב פרויקטי Apache כתובים ב-Java. אפליקציות Android נכתבות ב-Kotlin או ב-Java. ל-C# יש stack משולב יותר: ספק אחד מתחזק את השפה, סביבת הריצה, ה-framework לאינטרנט (ASP.NET Core), ה-ORM (Entity Framework) וה-IDE העיקרי (Visual Studio), ו-Unity שמה אותה במרכז של פיתוח המשחקים.

לשתי השפות יש שוק עבודה גדול, והאיזון ביניהן תלוי באזור ובתעשייה. C# חזקה בחברות שבנויות על Microsoft ו-Azure, בתוכנה לפיננסים ולבריאות, ובאולפני משחקים.

בחרו ב-C# אם אתם רוצים ליצור משחקים ב-Unity, לבנות אפליקציות דסקטופ ל-Windows, או לעבוד בחברת .NET. בחרו ב-Java אם אתם מכוונים ל-Android, ל-big data, או לחברה שה-backend שלה רץ על ה-JVM. כל אחת מהן מלמדת את המושגים שצריך בשביל השנייה: מחלקות, interfaces, generics, אוספים, חריגות וסביבת ריצה עם garbage collector.