C# vs Java：20年の歩みと思想の違いを技術的に整理する

はじめに

JavaエンジニアがC#（ASP.NET Core）を学ぶと、「似ているようで根本的に違う」と感じる瞬間がいくつかある。async/await、yield return、IAsyncEnumerable、タプル——これらをJavaで実現しようとすると、ライブラリが必要だったり、冗長な実装が必要だったりする。

本記事では、C#とJavaの設計思想の違いがどこから来るのかを、両言語の歴史的な歩みと具体的なコードで整理する。

1. 出発点の違い

	Java	C#
登場	1995年（Sun Microsystems）	2000年（Microsoft）
設計者	James Gosling	Anders Hejlsberg
前身	Oak（組込み向け言語）	Delphi / J++
コア思想	Write Once, Run Anywhere	開発者生産性の最大化
実行環境	JVM	CLR（Common Language Runtime）

HejlsbergはTurboPascal・Delphiの設計者でもあり、C#は「Javaの反省を踏まえて設計し直した言語」という側面が強い。

2. Javaの機能歩み（Java 1.0 〜 Java 25）

Java 1.0〜1.4（1995〜2002）：基礎の確立

オブジェクト指向、ガベージコレクション、例外処理
java.util（Collections Framework）
スレッド（Thread / Runnable）
JDBC（データベース接続の抽象化）

この時代はC#が存在しなかった。Javaが「エンタープライズの標準」として普及。

Java 5（2004）：近代化の第一歩

// ジェネリクス
List<String> names = new ArrayList<>();

// 拡張for文
for (String name : names) { ... }

// アノテーション
@Override
public String toString() { ... }

// enum
enum Day { MONDAY, TUESDAY, WEDNESDAY }

// オートボクシング
Integer x = 42; // int → Integer 自動変換

C#との比較： C# 2.0（2005）でジェネリクス導入。ほぼ同時期だが、C#のジェネリクスはランタイムレベルで実装されており、JavaのType Erasure（実行時に型情報が消える）との設計上の違いがある。

Java 8（2014）：最大の転換点

// ラムダ式
Runnable r = () -> System.out.println("Hello");

// Stream API（java.util.stream）
List<String> result = names.stream()
    .filter(n -> n.startsWith("A"))
    .map(String::toUpperCase)
    .collect(Collectors.toList());

// Optional
Optional<String> opt = Optional.ofNullable(getValue());
opt.ifPresent(System.out::println);

// インターフェースのdefaultメソッド
interface Greeter {
    default void greet() { System.out.println("Hello"); }
}

C#との比較： C#はLINQ（C# 3.0、2007年）で7年先行。JavaのStreamはLINQに近いが、collect(Collectors.toList()) の冗長さは今も残る。C#では .ToList()。

Java 9〜11（2017〜2018）：モジュールと型推論

// var（Java 10〜）
var list = new ArrayList<String>(); // 型推論

// モジュールシステム（Java 9）
module com.example.app {
    requires com.example.core;
    exports com.example.api;
}

// String新メソッド（Java 11）
"  hello  ".strip(); // trim()のUnicode対応版
"".isBlank();
"a\nb\nc".lines().count(); // 3

Java 11がLTSとして広く採用される。

Java 14〜16（2020〜2021）：表現力の向上

// Switch式（Java 14）
int numLetters = switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> 6;
    case TUESDAY -> 7;
    case THURSDAY, SATURDAY -> 8;
    case WEDNESDAY -> 9;
};

// yield（Switch式の中だけで使う）
int result = switch (x) {
    case 1 -> 10;
    default -> {
        int v = x * 2;
        yield v; // C#の yield return とは別物！
    }
};

// Record（Java 16）：イミュータブルなデータクラス
record Point(int x, int y) {}
// equals, hashCode, toString, getter が自動生成

// テキストブロック（Java 15）
String json = """
        {
            "name": "田中",
            "age": 25
        }
        """;

// instanceof パターンマッチング（Java 16）
if (obj instanceof String s) {
    System.out.println(s.length()); // キャスト不要
}

Java 17（2021）：LTS、封印クラス

// sealed class：継承できるクラスを制限
sealed interface Shape permits Circle, Rectangle {}
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}

// パターンマッチングとの組み合わせ（Java 21で完成）
double area = switch (shape) {
    case Circle c -> Math.PI * c.radius() * c.radius();
    case Rectangle r -> r.width() * r.height();
};

Java 21（2023）：Virtual Threads で革命

// Virtual Threads：OSスレッドを消費しない軽量スレッド
// ブロッキングI/OをしてもOSスレッドをブロックしない
try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    for (int i = 0; i < 100_000; i++) {
        executor.submit(() -> {
            // ブロッキングでDBアクセスしても高スループット
            var data = database.query("SELECT ...");
            process(data);
        });
    }
}

これはC#のasync/awaitとは逆のアプローチ。

C#：「非同期で書く」→ コンパイラがステートマシンに変換
Java：「同期で書く」→ ランタイムが軽量スレッドで高スループットを実現

Java 25（2025）：LTS最新版

パターンマッチングのさらなる強化（プリミティブ型パターン）
Structured Concurrency（構造化並行性）正式化
Scoped Values正式化
Project Valhalla（値オブジェクト）が近づく

3. C#の機能歩みと対比

C# 3.0（2007）：LINQ — Javaより7年早く関数型

// LINQ：クエリ構文
var result = from n in names
             where n.StartsWith("A")
             select n.ToUpper();

// メソッド構文（Javaのstream APIに近い）
var result = names
    .Where(n => n.StartsWith("A"))
    .Select(n => n.ToUpper())
    .ToList(); // Java: .collect(Collectors.toList())

C# 5.0（2012）：async/await — Javaとの最大の分岐点

// C#：言語レベルで非同期を抽象化
public async Task<string> FetchDataAsync()
{
    var response = await httpClient.GetStringAsync(url);
    return response;
}

// Java：ライブラリ（CompletableFuture）で対応
public CompletableFuture<String> fetchDataAsync() {
    return CompletableFuture.supplyAsync(() -> {
        // ここでは同期的なHTTPコールが必要
        return httpClient.get(url); // ブロッキング
    });
}

C#のawaitはコンパイラがステートマシンに変換する言語機能。Javaのコールバックチェーンより遥かに自然に書ける。

C# 8.0（2019）：IAsyncEnumerable + yield return

// 非同期ストリーム：言語レベルで実装
public async IAsyncEnumerable<int> ReadChunkedAsync()
{
    int index = 0;
    while (index < 100)
    {
        int[] chunk = await GetNextChunkAsync(index);
        if (chunk.Length == 0) yield break;
        foreach (var item in chunk)
            yield return item; // 状態を保持したまま一時停止
        index++;
    }
}

// 呼び出し側
await foreach (var item in ReadChunkedAsync())
{
    Console.WriteLine(item);
}

// Javaで同等のことをする場合：Project Reactorが必要
Flux<Integer> readChunked() {
    return Flux.generate(
        () -> 0,
        (index, sink) -> {
            int[] chunk = getNextChunk(index);
            if (chunk.length == 0) sink.complete();
            else for (int item : chunk) sink.next(item);
            return index + 1;
        }
    );
}

C# タプル vs Java Record

// C#：匿名タプル（名前不要）
(bool isValid, string message) Validate(string input)
    => (true, "OK");

var result = Validate("test");
Console.WriteLine(result.isValid);  // true
Console.WriteLine(result.message);  // OK

// Java：Recordは「名前が必須」
record ValidationResult(boolean isValid, String message) {}

ValidationResult validate(String input) {
    return new ValidationResult(true, "OK");
}
// 一時的な複数戻り値のためにクラス定義が必要

4. DI（依存性の注入）の比較

Spring Boot vs ASP.NET Core

// Spring Boot：アノテーションスキャンで自動検出
@Service
public class OrderService {
    @Autowired
    private OrderRepository repository;
}

@Repository
public class OrderRepositoryImpl implements OrderRepository { ... }

// ASP.NET Core：Program.cs に明示的に登録
builder.Services.AddScoped<IOrderRepository, OrderRepository>();
builder.Services.AddScoped<OrderService>();

// コンストラクタインジェクション（アノテーション不要）
public class OrderService
{
    private readonly IOrderRepository _repository;
    public OrderService(IOrderRepository repository)
        => _repository = repository;
}

思想の違い：

Spring：「コンテナが全部見つけてくれる」（暗黙的・魔法感あり）
ASP.NET Core：「何が登録されているか一目でわかる」（明示的・透明性）

5. ORM の比較

	Java	C#
フルORM	JPA / Hibernate	Entity Framework Core
マイクロORM	MyBatis	Dapper
マイグレーション	Flyway / Liquibase	EF Core Migrations
LINQ相当	JPQL / Criteria API	LINQ to Entities

// EF Core：LINQでSQLなしにクエリ
var orders = await context.Orders
    .Where(o => o.Status == "Active")
    .Include(o => o.Items)
    .ToListAsync();

// JPA：JPQLで文字列クエリ
List<Order> orders = em.createQuery(
    "SELECT o FROM Order o WHERE o.status = :status", Order.class)
    .setParameter("status", "Active")
    .getResultList();

6. 非同期モデルの設計思想対比

C# の思想：「複雑さを言語が隠す」
  async/await → コンパイラがステートマシン生成
  yield return → コンパイラがIEnumerator生成
  IAsyncEnumerable → 両方を組み合わせる
  開発者は「同期的に見えるコード」を書く

Java の思想：
  〜Java 20：「ライブラリで解決（Reactor、RxJava）」
  Java 21〜：「ランタイムで解決（Virtual Threads）」
  Reactor  → push型の非同期ストリーム
  VirtualThreads → 同期的に書いて高スループット

7. テストフレームワークの比較

機能	Java	C#
単体テスト	JUnit 5	xUnit / NUnit / MSTest
モック	Mockito	Moq
アサーション	AssertJ	FluentAssertions
Spring統合	@SpringBootTest	WebApplicationFactory

// JUnit 5 + Mockito
@Test
void shouldReturnOrder() {
    when(repository.findById(1L)).thenReturn(Optional.of(order));
    var result = service.getOrder(1L);
    assertThat(result).isPresent();
}

// xUnit + Moq
[Fact]
public async Task ShouldReturnOrder()
{
    _mockRepo.Setup(r => r.GetByIdAsync(1)).ReturnsAsync(order);
    var result = await _service.GetOrderAsync(1);
    Assert.NotNull(result);
}

8. まとめ：思想の違いの本質

┌─────────────────────────────────────────────┐
│                   Java                      │
│  「安定性」「後方互換」が最優先              │
│  重要機能 → まずライブラリで解決            │
│  標準化は慎重に、10年越しもある             │
│  Java 21〜 Virtual Threadsで逆転の発想      │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│                   C#                        │
│  「開発者生産性」が最優先                   │
│  重要機能 → 言語・コンパイラに組み込む      │
│  async/await、yield、LINQ全部言語機能       │
│  .NETと密に統合、一貫したAPI                │
└─────────────────────────────────────────────┘

どちらを選ぶか

ユースケース	推奨
エンタープライズJava資産の継続	Java + Spring
新規Webアプリ（Azure利用）	C# + ASP.NET Core
マイクロサービス（コンテナ）	どちらも可
高スループットAPI	C#（gRPC、SignalR）または Java 21 Virtual Threads
関数型プログラミング重視	Kotlin（JVM）または F#（.NET）

参考リンク