Java 開発者向け XamarinXamarin for Java Developers

Java 開発者は、C# のコードを再利用できる利点を活かしながら、Xamarin プラットフォームでの自分のスキルと既存の Java コードの活用方法について学びます。C# の構文が Java の構文とよく似ていることと、両方の言語でよく似た機能が提供されていることがわかります。さらに、開発が容易になる C# 固有の機能についても説明します。If you are a Java developer, you are well on your way to leveraging your skills and existing code on the Xamarin platform while reaping the code reuse benefits of C#. You will find that C# syntax is very similar to Java syntax, and that both languages provide very similar features. In addition, you'll discover features unique to C# that will make your development life easier.


この記事では Java 開発者向けの C# プログラミングの概要を提供し、主として Xamarin.Android アプリケーションの開発中に目にする C# 言語の機能に重点を置いています。This article provides an introduction to C# programming for Java developers, focusing primarily on the C# language features that you will encounter while developing Xamarin.Android applications. また、この記事では、Java の同等機能との違いについて説明し、Java では利用できない (Xamarin.Android に関連する) 重要な C# の機能を紹介します。Also, this article explains how these features differ from their Java counterparts, and it introduces important C# features (relevant to Xamarin.Android) that are not available in Java. 他の参考資料へのリンクが含まれているので、ここからさらに C# と .NET についての学習を進めることができます。Links to additional reference material are included, so you can use this article as a "jumping off" point for further study of C# and .NET.

Java に慣れていれば、C# の構文にもすぐに慣れることができます。If you are familiar with Java, you will feel instantly at home with the syntax of C#. C# の構文は Java の構文とよく似ており、C# は Java、C、C++ のような "中かっこ" 言語です。C# syntax is very similar to Java syntax – C# is a "curly brace" language like Java, C, and C++. 多くの点で、C# の構文は Java の構文のスーパーセットのように見えますが、名前の変更やキーワードの追加がいくつか行われています。In many ways, C# syntax reads like a superset of Java syntax, but with a few renamed and added keywords.

Java の重要な特徴の多くは C# にもあります。Many key characteristics of Java can be found in C#:

  • クラスに基づくオブジェクト指向プログラミングClass-based object-oriented programming

  • 厳密な型指定Strong typing

  • インターフェイスのサポートSupport for interfaces

  • ジェネリックGenerics

  • ガベージ コレクションGarbage collection

  • 実行時のコンパイルRuntime compilation

Java と C# はどちらも、マネージド実行環境で実行される中間言語にコンパイルされます。Both Java and C# are compiled to an intermediate language that is run in a managed execution environment. C# と Java はどちらも、静的に型指定され、文字列を変更不可能な型として処理します。Both C# and Java are statically-typed, and both languages treat strings as immutable types. どちらの言語も、単一ルートのクラス階層を使います。Both languages use a single-rooted class hierarchy. Java と同様に、C# は単一継承のみをサポートし、グローバル メソッドには対応していません。Like Java, C# supports only single inheritance and does not allow for global methods. どちらの言語においても、オブジェクトは new キーワードを使ってヒープ上に作成され、使われなくなるとガベージ コレクションが行われます。In both languages, objects are created on the heap using the new keyword, and objects are garbage-collected when they are no longer used. どちらも、try/catch セマンティクスで正式な例外処理のサポートを提供します。Both languages provide formal exception handling support with try/catch semantics. そして、スレッド管理と同期のサポートを提供します。Both provide thread management and synchronization support.

ただし、Java と C# には違う点も多くあります。However, there are many differences between Java and C#. 次に例を示します。For example:

  • Java は、暗黙的に型指定されたローカル変数をサポートしていません (C# は var キーワードをサポートします)。Java does not support implicitly-typed local variables (C# supports the var keyword).

  • Java ではパラメーターは値によってのみ渡すことができますが、C# では値だけでなく参照で渡すこともきますIn Java, you can pass parameters only by value, while in C# you can pass by reference as well as by value. (C# では、パラメーターの参照渡しに ref および out キーワードが提供されていますが、Java にはこれに相当する機能はありません)。(C# provides the ref and out keywords for passing parameters by reference; there is no equivalent to these in Java).

  • Java は、#define のようなプリプロセッサ ディレクティブをサポートしていません。Java does not support preprocessor directives like #define.

  • Java は符号なし整数型をサポートしていませんが、C# では ulonguintushortbyte などの符号なし整数型がサポートされます。Java does not support unsigned integer types, while C# provides unsigned integer types such as ulong, uint, ushort and byte.

  • Java は演算子のオーバーロードをサポートしていませんが、C# では演算子と変換をオーバーロードできます。Java does not support operator overloading; in C# you can overload operators and conversions.

  • Java の switch ステートメントでは、コードは次の switch セクションに移行できますが、C# では、すべての switch セクションの最後で switch を終了する必要があります (各セクションの最後を break ステートメントで閉じる必要があります)。In a Java switch statement, code can fall through into the next switch section, but in C# the end of every switch section must terminate the switch (the end of each section must close with a break statement).

  • Java ではメソッドによってスローされる例外を throws キーワードで指定しますが、C# にはチェックされた例外の概念がありません – throws キーワードは C# ではサポートされていません。In Java, you specify the exceptions thrown by a method with the throws keyword, but C# has no concept of checked exceptions – the throws keyword is not supported in C#.

  • C# では統合言語クエリ (LINQ) がサポートされており、予約語 fromselectwhere を使って、データベース クエリと同じような方法でコレクションに対するクエリを記述できます。C# supports Language-Integrated Query (LINQ), which lets you use the reserved words from, select, and where to write queries against collections in a way that is similar to database queries.

もちろん、C# と Java の間にはこの記事で説明しきれないほど多くの違いがあります。Of course, there are many more differences between C# and Java than can be covered in this article. また、Java も C# も発展し続けているので (たとえば、まだ Android ツールチェーンに含まれない Java 8 では、C# スタイルのラムダ式がサポートされています)、これらの相違点は時間とともに変化します。Also, both Java and C# continue to evolve (for example, Java 8, which is not yet in the Android toolchain, supports C#-style lambda expressions) so these differences will change over time. ここで示すのは、現時点で、Xamarin.Android を始めて使う Java 開発者が遭遇する最も重要な相違点だけです。Only the most important differences currently encountered by Java developers new to Xamarin.Android are outlined here.

現在、C# から Xamarin.Android に移植されている重要な機能の多くは、Android での Java 開発にはまだ利用できません。C# brings many key features to Xamarin.Android that are not currently readily available to Java developers on Android. 以下の機能は、より優れたコードを短時間で記述するのに役立ちます。These features can help you to write better code in less time:

  • プロパティ – C# のプロパティ システムでは、setter メソッドと getter メソッドを作成しなくても、メンバー変数に安全に直接アクセスできます。Properties – With C#'s property system, you can access member variables safely and directly without having to write setter and getter methods.

  • ラムダ式 – C# では、匿名メソッド (ラムダとも呼ばれます) を使うことで、機能をより簡潔かつ効率的に表現できます。Lambda Expressions – In C# you can use anonymous methods (also called lambdas) to express your functionality more succinctly and more efficiently. 一度しか使わないオブジェクトを記述するオーバーヘッドを回避することができ、パラメーターを追加することなくローカル状態をメソッドに渡すことができます。You can avoid the overhead of having to write one-time-use objects, and you can pass local state to a method without having to add parameters.

  • イベント処理 – C# では、"イベント ドリブン プログラミング" が言語レベルでサポートされており、オブジェクトは目的のイベントが発生したときに通知を受け取るように登録できます。Event Handling – C# provides language-level support for event-driven programming, where an object can register to be notified when an event of interest occurs. event キーワードでは、パブリッシャー クラスがイベント サブスクライバーへの通知に使うことができるマルチキャスト ブロードキャスト メカニズムが定義されています。The event keyword defines a multicast broadcast mechanism that a publisher class can use to notify event subscribers.

  • 非同期プログラミング – C# の非同期プログラミング機能 (async/await) では、アプリの応答性が維持されます。Asynchronous Programming – The asynchronous programming features of C# (async/await) keep apps responsive. この機能の言語レベルでのサポートにより、非同期プログラミングの実装が容易になり、エラーが減ります。The language-level support of this feature makes async programming easy to implement and less error-prone.

最後に、Xamarin では "バインド" と呼ばれる技術を使って、既存の Java のアセットを利用することもできます。Finally, Xamarin allows you to leverage existing Java assets via a technology known as binding. Xamarin の自動バインド ジェネレーターを使うことで、C# から Java の既存のコード、フレームワーク、ライブラリを呼び出すことができます。You can call your existing Java code, frameworks, and libraries from C# by making use of Xamarin's automatic binding generators. そのために必要なことは、Java でスタティック ライブラリを作成し、バインドを介して C# に公開するだけです。To do this, you simply create a static library in Java and expose it to C# via a binding.

Java から C# の開発へGoing From Java to C# Development

以下のセクションでは、C# と Java を "使い始める" ときの基本的な違いの概要を説明し、後のセクションでは、これらの言語でのオブジェクト指向の相違点について説明します。The following sections outline the basic "getting started" differences between C# and Java; a later section describes the object-oriented differences between these languages.

ライブラリとアセンブリLibraries vs. Assemblies

Java では、通常、関連するクラスを .jar ファイルにパッケージ化します。Java typically packages related classes in .jar files. 一方、C# と .NET では、再利用可能なプリコンパイル済みのコードは "アセンブリ" にパッケージ化され、通常、アセンブリは .dll ファイルとしてパッケージ化されます。In C# and .NET, however, reusable bits of precompiled code are packaged into assemblies, which are typically packaged as .dll files. アセンブリは C#/.NET コードの展開の単位であり、通常、各アセンブリは C# プロジェクトと関連付けられます。An assembly is a unit of deployment for C#/.NET code, and each assembly is typically associated with a C# project. アセンブリには、実行時に Just-In-Time コンパイルされる中間コード (IL) が含まれます。Assemblies contain intermediate code (IL) that is just-in-time compiled at runtime.

アセンブリについて詳しくは、「アセンブリとグローバル アセンブリ キャッシュ (C#)」トピックをご覧ください。For more information about assemblies, see the Assemblies and the Global Assembly Cache topic.

パッケージと名前空間Packages vs. Namespaces

C# では、namespace キーワードを使って関連する型をグループ化します。これは、Java の package キーワードと似ています。C# uses the namespace keyword to group related types together; this is similar to Java's package keyword. 通常、Xamarin.Android アプリは、そのアプリ用に作成された名前空間に存在します。Typically, a Xamarin.Android app will reside in a namespace created for that app. たとえば、次の C# コードでは、天気予報アプリ用の WeatherApp 名前空間ラッパーが宣言されています。For example, the following C# code declares the WeatherApp namespace wrapper for a weather-reporting app:

namespace WeatherApp

型のインポートImporting Types

外部の名前空間で定義されている型を使うときは、using ステートメントを使ってこれらの型をインポートします (これは、Java の import ステートメントとよく似ています)。When you make use of types defined in external namespaces, you import these types with a using statement (which is very similar to the Java import statement). Java では、次のようなステートメントを使って 1 つの型をインポートします。In Java, you might import a single type with a statement like the following:

import javax.swing.JButton

Java パッケージ全体をインポートするときは次のようなステートメントを使います。You might import an entire Java package with a statement like this:

import javax.swing.*

C# の using ステートメントの動作もよく似ていますが、ワイルドカードを指定せずにパッケージ全体をインポートすることができます。The C# using statement works in a very similar way, but it allows you to import an entire package without specifying a wildcard. たとえば、次の例のように、Xamarin.Android のソース ファイルの先頭で一連の using ステートメントが使われていることがよくあります。For example, you will often see a series of using statements at the beginning of Xamarin.Android source files, as seen in this example:

using System;
using Android.App;
using Android.Content;
using Android.Runtime;
using Android.Views;
using Android.Widget;
using Android.OS;
using System.Net;
using System.IO;
using System.Json;
using System.Threading.Tasks;

これらのステートメントは、SystemAndroid.AppAndroid.Content などの名前空間から機能をインポートします。These statements import functionality from the System, Android.App, Android.Content, etc. namespaces.


Java と C# はどちらも "ジェネリック" をサポートします。ジェネリックとは、コンパイル時に異なる型を挿入できるプレースホルダーです。Both Java and C# support generics, which are placeholders that let you plug in different types at compile time. ただし、ジェネリックの動作は C# では若干異なります。However, generics work slightly differently in C#. Java では、型消去により、型の情報はコンパイル時にのみ使用でき、実行時には使用できません。In Java, type erasure makes type information available only at compile time, but not at run time. これに対し、.NET の共通言語ランタイム (CLR) では、ジェネリック型の明示的なサポートが提供されています。これは、C# は実行時に型情報にアクセスできることを意味します。By contrast, the .NET common language runtime (CLR) provides explicit support for generic types, which means that C# has access to type information at runtime. 日常の Xamarin.Android 開発でこの違いの重要性に気付くことはあまりありませんが、リフレクションを使っている場合は、この機能に頼って実行時に型情報にアクセスしています。In day-to-day Xamarin.Android development, the importance of this distinction is not often apparent, but if you are using reflection, you will depend on this feature to access type information at run time.

Xamarin.Android では、レイアウト コントロールへの参照を取得するために使われているジェネリック メソッド FindViewById をよく目にします。In Xamarin.Android, you will often see the generic method FindViewById used to get a reference to a layout control. このメソッドは、参照するコントロールの種類を指定するジェネリック型パラメーターを受け取ります。This method accepts a generic type parameter that specifies the type of control to look up. 次に例を示します。For example:

TextView label = FindViewById<TextView> (Resource.Id.Label);

このコード例では、FindViewById はレイアウトで Label として定義されている TextView コントロールへの参照を取得し、TextView 型として返します。In this code example, FindViewById gets a reference to the TextView control that is defined in the layout as Label, then returns it as a TextView type.

ジェネリックについて詳しくは、「ジェネリック (C# プログラミング ガイド)」トピックをご覧ください。For more information about generics, see the Generics topic. Xamarin.Android でのジェネリック C# クラスのサポートにはいくつかの制限があることに注意してください。詳しくは、「Limitations」(制限事項) をご覧ください。Note that there are some limitations in Xamarin.Android support for generic C# classes; for more information, see Limitations.

オブジェクト指向プログラミングの機能Object-Oriented Programming Features

Java と C# では、非常によく似たオブジェクト指向プログラミングの表現方法が使われています。Both Java and C# use very similar object-oriented programming idioms:

  • すべてのクラスは、最終的に 1 つのルート オブジェクトから派生します – すべての Java オブジェクトは java.lang.Object から派生し、すべての C# オブジェクトは System.Object から派生します。All classes are ultimately derived from a single root object – all Java objects derive from java.lang.Object, while all C# objects derive from System.Object.

  • クラスのインスタンスは参照型です。Instances of classes are reference types.

  • インスタンスのプロパティやメソッドにアクセスするときは、"." 演算子を使います。When you access the properties and methods of an instance, you use the "." operator.

  • クラスのすべてのインスタンスは、new 演算子を使ってヒープ上に作成されます。All class instances are created on the heap via the new operator.

  • どちらの言語もガベージ コレクションを使うので、使われていないオブジェクトを明示的に解放する手段がありません (つまり、C++ のような delete キーワードはありません)。Because both languages use garbage collection, there is no way to explicitly release unused objects (i.e., there is not a delete keyword as there is in C++).

  • 継承を使ってクラスを拡張することができ、どちらの言語も基底クラスは型ごとに 1 つだけ許可されます。You can extend classes through inheritance, and both languages only allow a single base class per type.

  • インターフェイスを定義することができ、1 つのクラスで複数のインターフェイス定義から継承 (つまり実装) できます。You can define interfaces, and a class can inherit from (i.e., implement) multiple interface definitions.

一方で、重要な違いもいくつかあります。However, there are also some important differences:

  • Java には、匿名クラスと内部クラスという、C# ではサポートされていない 2 つの強力な機能がありますJava has two powerful features that C# does not support: anonymous classes and inner classes. (ただし、C# ではクラス定義を入れ子にすることができ、C# の入れ子になったクラスは Java の静的な入れ子になったクラスに似ています)。(However, C# does allow nesting of class definitions – C#'s nested classes are like Java's static nested classes.)

  • C# は C スタイルの構造体型 (struct) をサポートしますが、Java はサポートしません。C# supports C-style structure types (struct) while Java does not.

  • C# では、partial キーワードを使うことにより、異なるソース ファイルでクラス定義を実装することができます。In C#, you can implement a class definition in separate source files by using the partial keyword.

  • C# のインターフェイスではフィールドを宣言できません。C# interfaces cannot declare fields.

  • C# では、C++ スタイルのデストラクター構文を使ってファイナライザーを表現します。C# uses C++-style destructor syntax to express finalizers. 構文は Java の finalize メソッドと異なりますが、セマンティクスはほぼ同じですThe syntax is different from Java's finalize method, but the semantics are nearly the same. (C# のデストラクターは基底クラスのデストラクターを自動的に呼び出すのに対し、Java では super.finalize の明示的な呼び出しを使うことに注意してください)。(Note that in C#, destructors automatically call the base-class destructor – in contrast to Java where an explicit call to super.finalize is used.)

クラスの継承Class Inheritance

Java でクラスを拡張するには、extends キーワードを使います。To extend a class in Java, you use the extends keyword. C# でクラスを拡張するには、コロン (:) を使って派生を示します。To extend a class in C#, you use a colon (:) to indicate derivation. たとえば、Xamarin.Android アプリでは、次のコード フラグメントのようなクラスの派生をよく目にします。For example, in Xamarin.Android apps, you will often see class derivations that resemble the following code fragment:

public class MainActivity : Activity

この例では、MainActivityActivity クラスを継承します。In this example, MainActivity inherits from the Activity class.

Java でインターフェイスのサポートを宣言するには、implements キーワードを使います。To declare support for an interface in Java, you use the implements keyword. 一方、C# では、次のコードで示すように、継承するインターフェイスの名前をクラスのリストに追加するだけです。However, in C#, you simply add interface names to the list of classes to inherit from, as shown in this code fragment:

public class SensorsActivity : Activity, ISensorEventListener

この例では、SensorsActivityActivity を継承し、ISensorEventListener インターフェイスで宣言されている機能を実装します。In this example, SensorsActivity inherits from Activity and implements the functionality declared in the ISensorEventListener interface. インターフェイスのリストは基底クラスの後で指定する必要があることに注意してください (そうしないと、コンパイル時エラーになります)。Note that the list of interfaces must come after the base class (or you will get a compile-time error). 慣例として、C# のインターフェイス名の先頭には大文字の "I" が付いています。これにより、implements キーワードがなくても、どのクラスがインターフェイスか判断できます。By convention, C# interface names are prepended with an upper-case "I"; this makes it possible to determine which classes are interfaces without requiring an implements keyword.

C# でクラスがそれ以上サブクラス化されないようにしたい場合は、クラス名の前に sealed を付けます。Java では、クラス名の前に final を付けます。When you want to prevent a class from being further subclassed in C#, you precede the class name with sealed – in Java, you precede the class name with final.

C# のクラス定義について詳しくは、クラスに関するトピックと継承に関するトピックをご覧ください。For more about C# class definitions, see the Classes and Inheritance topics.


Java では、外部コードからクラスのメンバーを隠ぺいおよび保護しながら、メンバーに対する変更方法を制御するために、ミューテーター メソッド (setter) とインスペクター メソッド (getter) がよく使われます。In Java, mutator methods (setters) and inspector methods (getters) are often used to control how changes are made to class members while hiding and protecting these members from outside code. たとえば、Android の TextView クラスでは、getText メソッドと setText メソッドが提供されています。For example, the Android TextView class provides getText and setText methods. C# では、"プロパティ" と呼ばれる、似ていますがさらに直接的なメカニズムが提供されています。C# provides a similar but more direct mechanism known as properties. C# クラスのユーザーは、フィールドと似た方法でプロパティにアクセスできますが、各アクセスでは、実際には、呼び出し元に対して透過的なメソッド呼び出しが行われます。Users of a C# class can access a property in the same way as they would access a field, but each access actually results in a method call that is transparent to the caller. この "外から見えない" メソッドでは、他の値の設定、変換の実行、オブジェクトの状態の変更などの副作用を実装できます。This "under the covers" method can implement side effects such as setting other values, performing conversions, or changing object state.

プロパティは、UI (ユーザー インターフェイス) オブジェクトのメンバーに対するアクセスと変更によく使われます。Properties are often used for accessing and modifying UI (user interface) object members. 次に例を示します。For example:

int width = rulerView.MeasuredWidth;
int height = rulerView.MeasuredHeight;
rulerView.DrawingCacheEnabled = true;

この例では、幅と高さの値が、MeasuredWidth および MeasuredHeight プロパティにアクセスすることによって rulerView オブジェクトから読み取られています。In this example, width and height values are read from the rulerView object by accessing its MeasuredWidth and MeasuredHeight properties. これらのプロパティの読み取りでは、関連付けられている (ただし隠ぺいされた) フィールドの値が、バックグラウンドでフェッチされて、呼び出し元に返されます。When these properties are read, values from their associated (but hidden) field values are fetched behind the scenes and returned to the caller. rulerView オブジェクトは、幅と高さの値を 1 つの測定単位 (ピクセルなど) で格納し、MeasuredWidth プロパティと MeasuredHeight プロパティがアクセスされたら、別の測定単位 (ミリメートルなど) にその場で値を変換できます。The rulerView object may store width and height values in one unit of measurement (say, pixels) and convert these values on-the-fly to a different unit of measurement (say, millimeters) when the MeasuredWidth and MeasuredHeight properties are accessed.

また、rulerView オブジェクトには DrawingCacheEnabled という名前のプロパティもあります。コード例では、このプロパティを true に設定して、rulerView の描画キャッシュを有効にしています。The rulerView object also has a property called DrawingCacheEnabled – the example code sets this property to true to enable the drawing cache in rulerView. 見えないところで、関連付けられている隠ぺいされたフィールドが新しい値で更新され、場合によっては rulerView 状態の他の部分が変更されます。Behind the scenes, an associated hidden field is updated with the new value, and possibly other aspects of rulerView state are modified. たとえば、DrawingCacheEnabledfalse に設定されていると、rulerView はオブジェクトに既に蓄積されている描画キャッシュ情報を消去することもあります。For example, when DrawingCacheEnabled is set to false, rulerView may also erase any drawing cache information already accumulated in the object.

プロパティへのアクセスは、読み取り/書き込み、読み取り専用、または書き込み専用にすることができます。Access to properties can be read/write, read-only, or write-only. また、読み取りと書き込みに異なるアクセス修飾子を使うこともできます。Also, you can use different access modifiers for reading and writing. たとえば、1 つのプロパティに public 読み取りアクセスと private 書き込みアクセスを定義することができます。For example, you can define a property that has public read access but private write access.

C# のプロパティについて詳しくは、「プロパティ (C# プログラミング ガイド)」トピックをご覧ください。For more information about C# properties, see the Properties topic.

基底クラスのメソッドの呼び出しCalling Base Class Methods

C# で基底クラスのコンストラクターを呼び出すには、コロン (:) の後に base キーワードと初期化子のリストを記述します。この base コンストラクターの呼び出しは、派生コンストラクター パラメーター リストの直後に配置します。To call a base-class constructor in C#, you use a colon (:) followed by the base keyword and an initializer list; this base constructor call is placed immediately after the derived constructor parameter list. 基底クラスのコンストラクターは、派生コンストラクターに入ったときに呼び出されます。コンパイラは、メソッド本体の先頭に、基底コンストラクターへの呼び出しを挿入します。The base-class constructor is called on entry to the derived constructor; the compiler inserts the call to the base constructor at the start of the method body. 次のコード フラグメントでは、Xamarin.Android アプリで派生コンストラクターから呼び出される基底コンストラクターを示します。The following code fragment illustrates a base constructor called from a derived constructor in a Xamarin.Android app:

public class PictureLayout : ViewGroup
    public class PictureLayout (Context context)
           : base (context)

この例では、PictureLayout クラスは ViewGroup クラスから派生しています。In this example, the PictureLayout class is derived from the ViewGroup class. この例の PictureLayout コンストラクターは、context 引数を受け取り、base(context) の呼び出しでそれを ViewGroup コンストラクターに渡します。The PictureLayout constructor shown in this example accepts a context argument and passes it to the ViewGroup constructor via the base(context) call.

C# で基底クラスのメソッドを呼び出すには、base キーワードを使います。To call a base-class method in C#, use the base keyword. たとえば、Xamarin.Android アプリでは次に示すような基底メソッドの呼び出しをよく行います。For example, Xamarin.Android apps often make calls to base methods as shown here:

public class MainActivity : Activity
    protected override void OnCreate (Bundle bundle)
        base.OnCreate (bundle);

この場合、派生クラス (MainActivity) によって定義されている OnCreate メソッドは、基底クラス (Activity) の OnCreate メソッドを呼び出します。In this case, the OnCreate method defined by the derived class (MainActivity) calls the OnCreate method of the base class (Activity).

アクセス修飾子Access Modifiers

Java と C# はどちらも、publicprivateprotected の各アクセス修飾子をサポートしています。Java and C# both support the public, private, and protected access modifiers. ただし、C# ではさらに 2 つのアクセス修飾子がサポートされています。However, C# supports two additional access modifiers:

  • internal – クラスのメンバーは、現在のアセンブリ内でのみアクセスできます。internal – The class member is accessible only within the current assembly.

  • protected internal – クラスのメンバーは、定義アセンブリ、定義クラス、および派生クラス (アセンブリがアクセスできる内部と外部両方の派生クラス) 内でアクセスできます。protected internal – The class member is accessible within the defining assembly, the defining class, and derived classes (derived classes both inside and outside the assembly have access).

C# のアクセス修飾子について詳しくは、「アクセス修飾子 (C# プログラミング ガイド)」トピックをご覧ください。For more information about C# access modifiers, see the Access Modifiers topic.

仮想メソッドとオーバーライド メソッドVirtual and Override Methods

Java と C# はどちらも、同じ方法で関連するオブジェクトを処理する機能である "ポリモーフィズム" をサポートしています。Both Java and C# support polymorphism, the ability to treat related objects in the same manner. どちらの言語でも、基底クラスの参照を使って派生クラスのオブジェクトを参照でき、派生クラスのメソッドはその基底クラスのメソッドをオーバーライドできます。In both languages, you can use a base-class reference to refer to a derived-class object, and the methods of a derived class can override the methods of its base classes. どちらの言語にも、派生クラスのメソッドによって置き換えられるように設計された基底クラスのメソッドである "仮想" メソッドの概念があります。Both languages have the concept of a virtual method, a method in a base class that is designed to be replaced by a method in a derived class. Java と同様に、C# は abstract のクラスとメソッドをサポートします。Like Java, C# supports abstract classes and methods.

ただし、仮想メソッドの宣言方法と仮想メソッドをオーバーライドする方法に関して、Java と C# ではいくつか違いがあります。However, there are some differences between Java and C# in how you declare virtual methods and override them:

  • C# の既定では、メソッドは仮想ではありません。In C#, methods are non-virtual by default. 親クラスで virtual キーワードを使って、オーバーライドされるメソッドに明示的にラベルを付ける必要があります。Parent classes must explicitly label which methods are to be overridden by using the virtual keyword. これに対し、Java ではすべてのメソッドが既定で仮想メソッドになります。By contrast, all methods in Java are virtual methods by default.

  • C# でメソッドがオーバーライドされないようにするには、単に virtual キーワードを省略するだけです。To prevent a method from being overridden in C#, you simply leave off the virtual keyword. 一方、Java では、final キーワードを使ってメソッドを "オーバーライド不可" としてマークする必要があります。By contrast, Java uses the final keyword to mark a method with "override is not allowed."

  • C# の派生クラスでは、override キーワードを使って、仮想基底クラスのメソッドがオーバーライドされていることを明示的に示す必要があります。C# derived classes must use the override keyword to explicitly indicate that a virtual base-class method is being overridden.

C# によるポリモーフィズムのサポートについて詳しくは、「ポリモーフィズム (C# プログラミング ガイド)」トピックをご覧ください。For more information about C#'s support for polymorphism, see the Polymorphism topic.

ラムダ式Lambda Expressions

C# では、自分を囲んでいるメソッドの状態にアクセスできるインラインの匿名メソッドである "クロージャ" を作成できます。C# makes it possible to create closures: inline, anonymous methods that can access the state of the method in which they are enclosed. ラムダ式を使うと、Java で実装する場合より少ない行数で、同じ機能を実装できます。Using lambda expressions, you can write fewer lines of code to implement the same functionality that you might have implemented in Java with many more lines of code.

ラムダ式では、Java で 1 回だけ使うクラスまたは匿名クラスの作成に伴う余分な手続きを省くことができます。代わりに、メソッド コードのビジネス ロジックをインラインに記述できます。Lambda expressions make it possible for you to skip the extra ceremony involved in creating a one-time-use class or anonymous class as you would in Java – instead, you can just write the business logic of your method code inline. また、ラムダはそれを囲んでいるメソッドの変数にアクセスできるので、メソッドのコードに状態を渡すために長いパラメーター リストを作成する必要がありません。Also, because lambdas have access to the variables in the surrounding method, you don't have to create a long parameter list to pass state to your method code.

C# では、次のように => 演算子を使ってラムダ式を作成します。In C#, lambda expressions are created with the => operator as shown here:

(arg1, arg2, ...) => {
    // implementation code

Xamarin.Android では、イベント ハンドラーの定義にラムダ式がよく使われます。In Xamarin.Android, lambda expressions are often used for defining event handlers. 次に例を示します。For example:

button.Click += (sender, args) => {
    clickCount += 1;    // access variable in surrounding code
    button.Text = string.Format ("Clicked {0} times.", clickCount);

この例のラムダ式のコード (中かっこ内のコード) は、クリック数をインクリメントし、クリック数を表示する button テキストを更新しています。In this example, the lambda expression code (the code within the curly braces) increments a click count and updates the button text to display the click count. このラムダ式は、ボタンをタップするたびに呼び出されるクリック イベント ハンドラーとして、button オブジェクトに登録されますThis lambda expression is registered with the button object as a click event handler to be called whenever the button is tapped. (イベント ハンドラーについては後で詳しく説明します)。この簡単な例の sender および args パラメーターは、ラムダ式のコードでは使われていませんが、イベント登録のメソッド シグネチャ要件を満たすためにラムダ式で必要です。(Event handlers are explained in more detail below.) In this simple example, the sender and args parameters are not used by the lambda expression code, but they are required in the lambda expression to meet the method signature requirements for event registration. 内部では、C# のコンパイラはボタン クリック イベントが発生するたびに呼び出される匿名メソッドに、ラムダ式を変換します。Under the hood, the C# compiler translates the lambda expression into an anonymous method that is called whenever button click events take place.

C# とラムダ式について詳しくは、「ラムダ式 (C# プログラミング ガイド)」トピックをご覧ください。For more information about C# and lambda expressions, see the Lambda Expressions topic.

イベント処理Event Handling

"イベント" は、何か重要なことがオブジェクトに起きたときに、そのオブジェクトが登録されているサブスクライバーに通知するための手段です。An event is a way for an object to notify registered subscribers when something interesting happens to that object. Java では、サブスクライバーはコールバック メソッドを含む Listener インターフェイスを通常実装しますが、C# では、"デリゲート" によって言語レベルでイベント処理のサポートが提供されます。Unlike in Java, where a subscriber typically implements a Listener interface that contains a callback method, C# provides language-level support for event handling through delegates. "デリゲート" は、オブジェクト指向でのタイプ セーフな関数ポインターのようなものであり、オブジェクト参照とメソッド トークンをカプセル化しています。A delegate is like an object-oriented type-safe function pointer – it encapsulates an object reference and a method token. クライアント オブジェクトでイベントをサブスクライブする必要がある場合は、デリゲートを作成して、通知オブジェクトにデリゲートを渡します。If a client object wants to subscribe to an event, it creates a delegate and passes the delegate to the notifying object. イベントが発生すると、通知オブジェクトはデリゲート オブジェクトによって表されるメソッドを呼び出し、サブスクライブしているクライアント オブジェクトにイベントを通知します。When the event occurs, the notifying object invokes the method represented by the delegate object, notifying the subscribing client object of the event. C# では、基本的に、イベント ハンドラーはデリゲートを介して呼び出されるメソッドにすぎません。In C#, event handlers are essentially nothing more than methods that are invoked through delegates.

デリゲートについて詳しくは、「デリゲート (C# プログラミング ガイド)」トピックをご覧ください。For more information about delegates, see the Delegates topic.

C# の場合、イベントは "マルチキャスト" です。つまり、イベント発生の通知を、複数のリスナーが受け取ることができます。In C#, events are multicast; that is, more than one listener can be notified when an event takes place. この違いは、Java と C# でのイベント登録の構文上の違い考えるとわかります。This difference is observed when you consider the syntactical differences between Java and C# event registration. Java では、SetXXXListener を呼び出してイベント通知に登録します。C# では、+= 演算子を使い、イベント リスナーのリストにデリゲートを "追加する" ことによって、イベント通知に登録します。In Java you call SetXXXListener to register for event notifications; in C# you use the += operator to register for event notifications by "adding" your delegate to the list of event listeners. Java では SetXXXListener を呼び出して登録を解除しますが、C# では、-= を使ってリスナーのリストからデリゲートを "差し引き" ます。In Java, you call SetXXXListener to unregister, while in C# you use the -= to "subtract" your delegate from the list of listeners.

Xamarin.Android では、ユーザーが UI コントロールに対して何かを行ったときにオブジェクトに通知するためにイベントがよく使われます。In Xamarin.Android, events are often used for notifying objects when a user does something to a UI control. 通常、UI コントロールには event キーワードを使って定義されたメンバーがあります。その UI コントロールからのイベントをサブスクライブするには、これらのメンバーにデリゲートをアタッチします。Normally, a UI control will have members that are defined using the event keyword; you attach your delegates to these members to subscribe to events from that UI control.

イベントをサブスクライブするには:To subscribe to an event:

  1. イベント発生時に呼び出されるメソッドを参照するデリゲート オブジェクトを作成します。Create a delegate object that refers to the method that you want to be invoked when the event occurs.

  2. += 演算子を使って、サブスクライブするイベントにデリゲートをアタッチします。Use the += operator to attach your delegate to the event you are subscribing to.

次の例では、ボタンのクリックをサブスクライブするデリゲートを (delegate キーワードを明示的に使って) 定義しています。The following example defines a delegate (with an explicit use of the delegate keyword) to subscribe to button clicks. このボタン クリック ハンドラーは、新しいアクティビティを開始します。This button-click handler starts a new activity:

startActivityButton.Click += delegate {
    Intent intent = new Intent (this, typeof (MyActivity));
    StartActivity (intent);

ただし、ラムダ式を使ってイベントに登録し、delegate キーワード全体を省略することもできます。However, you also can use a lambda expression to register for events, skipping the delegate keyword altogether. 次に例を示します。For example:

startActivityButton.Click += (sender, e) => {
    Intent intent = new Intent (this, typeof (MyActivity));
    StartActivity (intent);

この例の startActivityButton オブジェクトには、特定のメソッド シグネチャ (送信元とイベントの引数を受け取り、void を返す) を持つデリゲートを期待するイベントがあります。In this example, the startActivityButton object has an event that expects a delegate with a certain method signature: one that accepts sender and event arguments and returns void. しかし、そのようなデリゲートまたはそのメソッドをわざわざ明示的に定義したくないので、メソッドのシグネチャを (sender, e) と宣言し、ラムダ式を使ってイベント ハンドラーの本体を実装します。However, because we don't want to go to the trouble to explicitly define such a delegate or its method, we declare the signature of the method with (sender, e) and use a lambda expression to implement the body of the event handler. sender および e パラメーターを使っていない場合でも、このパラメーター リストを宣言する必要があることに注意してください。Note that we have to declare this parameter list even though we aren't using the sender and e parameters.

デリゲートのサブスクライブを解除することは (-= 演算子を使って) できますが、ラムダ式はサブスクライブ解除できないことに注意してください。サブスクライブ解除しようとすると、メモリ リークが発生する可能性があります。It is important to remember that you can unsubscribe a delegate (via the -= operator), but you cannot unsubscribe a lambda expression – attempting to do so can cause memory leaks. ラムダ形式のイベント登録は、ハンドラーをイベントからサブスクライブ解除しない場合にのみ使ってください。Use the lambda form of event registration only when your handler will not unsubscribe from the event.

Xamarin.Android のコードでは、通常、イベント ハンドラーの宣言にラムダ式を使います。Typically, lambda expressions are used to declare event handlers in Xamarin.Android code. この簡略化されたイベント ハンドラーの宣言方法は最初はわかりにくいかもしれませんが、コードを読み書きする時間が大幅に短縮されます。This shorthand way to declare event handlers may seem cryptic at first, but it saves an enormous amount of time when you are writing and reading code. このパターン (Xamarin.Android のコードでは頻繁に出現します) の認識に慣れてくれば、アプリケーションのビジネス ロジックについて考える時間が増え、構文に関することにかかる時間は減ります。With increasing familiarity, you become accustomed to recognizing this pattern (which occurs frequently in Xamarin.Android code), and you spend more time thinking about the business logic of your application and less time wading through syntactical overhead.

非同期プログラミングAsynchronous Programming

"非同期プログラミング" は、アプリケーションの全体的な応答性を向上させる方法です。Asynchronous programming is a way to improve the overall responsiveness of your application. 非同期プログラミング機能を使うと、アプリの一部が時間のかかる処理によってブロックされている間も、アプリ コードの残りの部分は実行し続けることができます。Asynchronous programming features make it possible for the rest of your app code to continue running while some part of your app is blocked by a lengthy operation. 非同期的に作成されていない場合に、アプリ全体が停止したように見える原因になる可能性のある操作の例としては、Web へのアクセス、画像の処理、ファイルの読み取り/書き込みなどがあります。Accessing the web, processing images, and reading/writing files are examples of operations that can cause an entire app to appear to freeze up if it is not written asynchronously.

C# には、async および await キーワードによる言語レベルでの非同期プログラミングのサポートが含まれます。C# includes language-level support for asynchronous programming via the async and await keywords. これらの言語機能を使うと、アプリケーションのメイン スレッドをブロックすることなく、実行時間の長いタスクを実行するコードを、とても簡単に記述できます。These language features make it very easy to write code that performs long-running tasks without blocking the main thread of your application. 簡単に説明すると、メソッドで async キーワードを使うことにより、メソッドのコードが非同期に実行され、呼び出し元のスレッドをブロックしないことを示します。Briefly, you use the async keyword on a method to indicate that the code in the method is to run asynchronously and not block the caller's thread. async でマークされているメソッドを呼び出すときは、await キーワードを使います。You use the await keyword when you call methods that are marked with async. コンパイラは、await を、メソッドの実行がバックグラウンド スレッドに移動される (タスクが呼び出し元に返される) ポイントとして解釈します。The compiler interprets the await as the point where your method execution is to be moved to a background thread (a task is returned to the caller). このタスクが完了すると、コードの await ポイントで呼び出し元のスレッドでのコード実行が再開されて、async の呼び出しの結果が返されます。When this task completes, execution of the code resumes on the caller's thread at the await point in your code, returning the results of the async call. 慣例として、非同期に実行するメソッドの名前にはサフィックス Async を付けます。By convention, methods that run asynchronously have Async suffixed to their names.

Xamarin.Android アプリケーションでは、実行時間の長い操作がバックグラウンド タスクで行われている間は、通常、asyncawait を使って、ユーザー入力 ([キャンセル] ボタンのタップなど) に応答できるように UI スレッドを解放します。In Xamarin.Android applications, async and await are typically used to free up the UI thread so that it can respond to user input (such as the tapping of a Cancel button) while a long-running operation takes place in a background task.

次の例では、ボタン クリック イベント ハンドラーにより、非同期操作が Web からイメージをダウンロードします。In the following example, a button click event handler causes an asynchronous operation to download an image from the web:

downloadButton.Click += downloadAsync;
async void downloadAsync(object sender, System.EventArgs e)
    webClient = new WebClient ();
    var url = new Uri ("");
    byte[] bytes = null;

    bytes = await webClient.DownloadDataTaskAsync(url);

    // display the downloaded image ...

この例では、ユーザーが downloadButton コントロールをクリックすると、downloadAsync イベント ハンドラーは WebClient オブジェクトと Uri オブジェクトを作成して、指定された URL からイメージを取得します。In this example, when the user clicks the downloadButton control, the downloadAsync event handler creates a WebClient object and a Uri object to fetch an image from the specifed URL. 次に、この URL を使って WebClient オブジェクトの DownloadDataTaskAsync メソッドを呼び出し、イメージを取得します。Next, it calls the WebClient object's DownloadDataTaskAsync method with this URL to retrieve the image.

downloadAsync のメソッド宣言の前に async キーワードが付いていて、非同期に実行してタスクを返すことを示していることに注意してください。Notice that the method declaration of downloadAsync is prefaced by the async keyword to indicate that it will run asynchronously and return a task. また、DownloadDataTaskAsync の呼び出しの前に await キーワードが付いていることにも注意してください。Also note that the call to DownloadDataTaskAsync is preceded by the await keyword. アプリは、イベント ハンドラーの実行 (await が出現した場所で開始します) を、DownloadDataTaskAsync が完了して戻るまでバックグラウンド スレッドに移動します。The app moves the execution of the event handler (starting at the point where await appears) to a background thread until DownloadDataTaskAsync completes and returns. その間も、アプリの UI スレッドはユーザー入力に応答して、他のコントロールに対するイベント ハンドラーを発動できます。Meanwhile, the app's UI thread can still respond to user input and fire event handlers for the other controls. DownloadDataTaskAsync が完了すると (数秒かかることがあります)、bytes 変数に DownloadDataTaskAsync の呼び出しの結果が設定されて実行が再開され、イベント ハンドラーの残りのコードが呼び出し元の (UI) スレッドでダウンロードされたイメージを表示します。When DownloadDataTaskAsync completes (which may take several seconds), execution resumes where the bytes variable is set to the result of the call to DownloadDataTaskAsync, and the remainder of the event handler code displays the downloaded image on the caller's (UI) thread.

C# での async/await の概要については、「Asynchronous Programming with Async and Await」(Async および Await を使用した非同期プログラミング (C# および Visual Basic)) のトピックをご覧ください。For an introduction to async/await in C#, see the Asynchronous Programming with Async and Await topic. Xamarin による非同期プログラミング機能のサポートについて詳しくは、「非同期サポートの概要」をご覧ください。For more information about Xamarin support of asynchronous programming features, see Async Support Overview.

キーワードの違いKeyword Differences

Java で使われている言語キーワードの多くは、C# でも使われます。Many language keywords used in Java are also used in C#. また、次の表で示すように、Java キーワードと同等の機能を持っていても C# では名前が異なるものもいくつかあります。There are also a number of Java keywords that have an equivalent but differently-named counterpart in C#, as listed in this table:

JavaJava C#C# 説明Description
boolean boolbool ブール値 true および false を宣言するために使われます。Used for declaring the boolean values true and false.
extends : 継承するクラスとインターフェイスの前に付きます。Precedes the class and interfaces to inherit from.
implements : 継承するクラスとインターフェイスの前に付きます。Precedes the class and interfaces to inherit from.
import usingusing 名前空間から型をインポートし、名前空間の別名の作成にも使われます。Imports types from a namespace, also used for creating a namespace alias.
final sealedsealed クラスの派生を防止します。派生クラスでメソッドとプロパティがオーバーライドされるのを防止します。Prevents class derivation; prevents methods and properties from being overridden in derived classes.
instanceof isis オブジェクトに特定の型との互換性があるかどうかを評価します。Evaluates whether an object is compatible with a given type.
native externextern 外部で実装されているメソッドを宣言します。Declares a method that is implemented externally.
package namespacenamespace 関連する一連のオブジェクトのスコープを宣言します。Declares a scope for a related set of objects.
T... params Tparams T 可変数個の引数を受け取るメソッド パラメーターを指定します。Specifies a method parameter that takes a variable number of arguments.
super basebase 派生クラス内から親クラスのメンバーにアクセスするために使われます。Used to access members of the parent class from within a derived class.
synchronized locklock ロックの取得と解放でコードの重要なセクションをラップします。Wraps a critical section of code with lock acquisition and release.

また、C# に固有で、Java には対応するもののないキーワードも多くあります。Also, there are many keywords that are unique to C# and have no counterpart in Java. Xamarin.Android のコードでは、以下の C# キーワードがよく使われます (この表は、Xamarin.Android のサンプル コードを読むときに参照すると便利です)。Xamarin.Android code often makes use of the following C# keywords (this table is useful to refer to when you are reading through Xamarin.Android sample code):

C#C# 説明Description
asas 互換性のある参照型の間、または null 許容型の間の変換を実行します。Performs conversions between compatible reference types or nullable types.
asyncasync メソッドまたはラムダ式が非同期であることを指定します。Specifies that a method or lambda expression is asynchronous.
awaitawait タスクが完了するまで、メソッドの実行を中断します。Suspends the execution of a method until a task completes.
bytebyte 符号なしの 8 ビット整数型です。Unsigned 8-bit integer type.
delegatedelegate メソッドまたは匿名メソッドをカプセル化するために使われます。Used to encapsulate a method or anonymous method.
enumenum 列挙型つまり名前付き定数のセットを宣言します。Declares an enumeration, a set of named constants.
eventevent パブリッシャー クラスのイベントを宣言します。Declares an event in a publisher class.
fixedfixed 変数が再配置されないようにします。Prevents a variable from being relocated.
get プロパティの値を取得するアクセサー メソッドを定義します。Defines an accessor method that retrieves the value of a property.
inin パラメーターがジェネリック インターフェイスの弱い派生型を受け付けられるようにします。Enables a parameter to accept a less derived type in a generic interface.
objectobject .NET Framework のオブジェクト型の別名です。An alias for the Object type in the .NET framework.
outout パラメーター修飾子またはジェネリック型パラメーターの宣言です。Parameter modifier or generic type parameter declaration.
overrideoverride 継承されたメンバーの実装を拡張または修正します。Extends or modifies the implementation of an inherited member.
partialpartial 定義が複数のファイルに分割されることを宣言します。または、実装からのメソッド定義を分割します。Declares a definition to be split into multiple files, or splits a method definition from its implementation.
readonlyreadonly クラスのメンバーが、宣言時にのみ、またはクラス コンストラクターによってのみ、割り当てられることを宣言します。Declares that a class member can be assigned only at declaration time or by the class constructor.
refref 値ではなく、参照によって引数が渡されるようにします。Causes an argument to be passed by reference rather than by value.
setset プロパティの値を設定するアクセサー メソッドを定義します。Defines an accessor method that sets the value of a property.
stringstring .NET Framework の文字列型の別名です。Alias for the String type in the .NET framework.
structstruct 関連する変数のグループをカプセル化する値の型です。A value type that encapsulates a group of related variables.
typeoftypeof オブジェクトの型を取得します。Obtains the type of an object.
varvar 暗黙的に型指定されたローカル変数を宣言します。Declares an implicitly-typed local variable.
valuevalue クライアント コードがプロパティに代入する値を参照します。References the value that client code wants to assign to a property.
virtualvirtual 派生クラスでのメソッドのオーバーライドを許可します。Allows a method to be overridden in a derived class.

既存の Java コードとの相互運用Interoperating with Existing Java Code

C# に変換したくない既存の Java 機能がある場合は、2 つの方法で、Xamarin.Android アプリケーションの既存の Java ライブラリを再利用できます。If you have existing Java functionality that you do not want to convert to C#, you can reuse your existing Java libraries in Xamarin.Android applications via two techniques:

  • Java バインド ライブラリを作成する – この方法では、Xamarin ツールを使って Java 型を囲む C# ラッパーを生成します。Create a Java Bindings Library – Using this approach, you use Xamarin tools to generate C# wrappers around Java types. このようなラッパーは "バインド" と呼ばれます。These wrappers are called bindings. 結果として、Xamarin.Android アプリケーションはこれらのラッパーを呼び出すことによって .jar ファイルを使うことができます。As a result, your Xamarin.Android application can use your .jar file by calling into these wrappers.

  • Java ネイティブ インターフェイスJava ネイティブ インターフェイス (JNI) は、C# アプリによる Java コードの呼び出し、または Java コードによる C# アプリの呼び出しを可能にするフレームワークです。Java Native Interface – The Java Native Interface (JNI) is a framework that makes it possible for C# apps to call or be called by Java code.

これらの手法について詳しくは、「Java Integration Overview」(Java 統合の概要) をご覧ください。For more information about these techniques, see Java Integration Overview.

関連項目For Further Reading

MSDN の「C# プログラミング ガイド」は C# プログラミング言語の学習を始めるときに役立ちます。「C# リファレンス」を使うと C# 言語の特定の機能を検索できます。The MSDN C# Programming Guide is a great way to get started in learning the C# programming language, and you can use the C# Reference to look up particular C# language features.

Java の知識には、少なくとも Java 言語の知識と同程度の Java クラス ライブラリの知識が必要ですが、同様に C# の実用的な知識には、.NET Framework についての知識がある程度必要です。In the same way that Java knowledge is at least as much about familiarity with the Java class libraries as knowing the Java language, practical knowledge of C# requires some familiarity with the .NET framework. Microsoft の「Java 開発者のための、C# および .NET Framework への移行」 学習パケットは、Java の観点から (C# についてより深く理解しながら) .NET Framework を詳しく学習するのによい方法です。Microsoft's Moving to C# and the .NET Framework, for Java Developers learning packet is a good way to learn more about the .NET framework from a Java perspective (while gaining a deeper understanding of C#).

C# で最初の Xamarin.Android プロジェクトに取り組む準備ができたら、Microsoft の「Hello, Android」シリーズが、初めての Xamarin.Android アプリケーションの作成と、Xamarin での Android アプリケーション開発に関する基本事項の理解のさらなる前進に役立ちます。When you are ready to tackle your first Xamarin.Android project in C#, our Hello, Android series can help you build your first Xamarin.Android application and further advance your understanding of the fundamentals of Android application development with Xamarin.


この記事では、Java 開発者の観点から Xamarin.Android C# プログラミング環境の概要について説明しました。This article provided an introduction to the Xamarin.Android C# programming environment from a Java developer's perspective. C# と Java の類似点と、実用での相違点を指摘しました。It pointed out the similarities between C# and Java while explaining their practical differences. アセンブリと名前空間、外部の型をインポートする方法、およびアクセス修飾子、ジェネリック、クラスの派生、基底クラスのメソッドの呼び出し、メソッドのオーバーライド、イベント処理の相違点の概要について説明しました。It introduced assemblies and namespaces, explained how to import external types, and provided an overview of the differences in access modifiers, generics, class derivation, calling base-class methods, method overriding, and event handling. プロパティ、async/await 非同期プログラミング、ラムダ、C# のデリゲート、C# のイベント処理システムなど、Java では使用できない C# の機能について説明しました。It introduced C# features that are not available in Java, such as properties, async/await asynchronous programming, lambdas, C# delegates, and the C# event handling system. 重要な C# のキーワードの表を示し、既存の Java ライブラリと相互運用する方法を説明し、さらに学習するための関連ドキュメントへのリンクを提供しました。It included tables of important C# keywords, explained how to interoperate with existing Java libraries, and provided links to related documentation for further study.