魂のプログラミング

魂のプログラミングとはシンプルな信念である。

プログラムコードは一行一行すべてに魂がこもっていなければならない

という信念である。

以前プログラム製造の現場で若手プログラマを指導している際に, つい「この行には魂がこもっていない」という言い方を何度かしていたところ, 周囲の数人の SE にそのような物言いが伝染してしまった。後日, その中の一人がソースコードレビューに参加したときに「このソースコードには魂がこもっていない」と指摘し, 指摘されたプログラマが反応に窮したというエピソードを聞いた。「魂のプログラミング」という言葉は, このエピソードを聞いたときにふと私の頭の中に浮かんだ言葉である。

「プログラムコードの一行に魂がこもる」とは, 別に宗教めいた意味ではない。一言で言うならば,

プログラムコードのあらゆる行に目的がある

とか

どの一行についてもその目的が必ず説明できる

というような意味である。空行にさえ説明可能な目的があるべきだと私は考えている。

本稿では魂のプログラミングを実践する上での教訓を, 例を挙げながら解説していくことにする。まだまとまっておらず, 多分に断片的であるが, 魂のプログラミングの一端は感じられるのではないだろうか。

やりたいことを簡潔に表現する

やりたいことを正確に理解する

唐突ではあるが, 「endian (エンディアン)」という言葉を聴いたことがあるだろうか。ガリバー旅行記に由来するこの言葉は, 多桁数値を表現する際, 上位桁から下位桁に向かって記述する (big endian) か, 下位桁から上位桁に向かって記述する (little endian) かの約束事を意味している。ちなみに算用数字による 123 などの表記は big endian で, 百二十三を敢えて little endian で書けば 321 となる。太古の昔から多くのコンピュータはどちらかの宗派に属している。(少数派として変態 endian の VAX などや, endianess 切替機能付きコンピュータもある。)

昔, このような質問を受けたことがある。

プログラムを実行しているコンピュータが big endian であるか調べ, もしそうでなかったら 32 ビット値のバイト順を逆転させたい。C でどう書くのがスマートですか

この質問にもし条件反射的に回答するとすれば, たとえば以下のようになる。

しかし, そう回答する前にこの質問者が本当は何がしたかったのか考えてみよう。3 分ほどじっくり考えると, 実はこの質問者は客先のコンピュータの endianess を研究したいわけでも, バイト順を逆転させるトリックを知りたいわけでもないことに気付く。質問者が本当にやりたかったことは,

4 バイト big endian で格納された 32 ビット値を取出す

という処理である。

処理は 1 行で完結する。こちらの方がスマートで分かりやすいコードであるが, これは別にプログラミングスキルの問題ではなく, それ以前の問題であったことが分かる。すなわち, 自分が本当は何をしたいのか理解していなかったのである。

最適な手段で表現する

短いコードは常に長いコードより優れている。より良いコードを書きたいなら, 第一に短く簡潔なコードを目指すべきである。

プログラミング言語にはそれぞれ特有の考え方や機能がある。そのため, 最適なコードは利用するプログラミング言語によって変わってくる。この観点からもプログラミング言語に関する正確な知識は重要である。

例として, まず JAVA で素朴な線形リストクラスを実装してみよう。

同様な実装を C++ のテンプレートで行う。C/C++ のポインタを効果的に利用すると pushBack メソッド (C++ では push_back メンバ関数) の条件分岐が不要となる。

なぜこれでよいのかは, じっくり考えてみて欲しい。

アイディアや疑問は実験してみる

次のコード片はコンパイルできるだろうか。もしできたとして実行すると何が起こるのだろうか。

JAVA である程度経験を積んだプログラマなら, 答を知っていると思うが, 分からなくても実際やってみることは 3 分もあればできる。

前節で紹介した例の通り, 少なくともポインタがある分 C++ は JAVA よりも表現力で勝っているといえる。しかし, JAVA でも C++ のポインタを真似すれば同様の表現が可能なのではないか, というアイディアを持ったとしよう。

早速頑張ってみよう。

よく JAVA にはポインタがないと言われたり, JAVA にはポインタしかないと言われたりする。JAVA のオブジェクト参照と C/C++ のポインタ (の値) の考え方は似ているが, 決定的に違うのは C/C++ はポインタ型を含めてあらゆる型のデータオブジェクトへのポインタが & 演算子で簡単に作成できるという点である。そこで & 演算子を適用する可能性のあるポインタ (オブジェクト参照) を予め Pointer オブジェクトとしてラップしておけばうまく真似できるのではないかと予想が立つ。詳細な説明は省略するが, その考え方で前節の例を書き直すと, 次のコードとなった。

ひとまず実験は成功である。しかし実験は実験であって, こんな冗談コードを実際の現場では利用するべきではない。この Pointe クラスは if 文を一つ減らすための JAVA での最適な手段とは決して言えない。

境界に注意する

次の中途半端に魂のこもったコードを見てもらいたい。バグが 3 つほど巧妙に仕込んであるのだが, 気付くだろうか。

慎重に考えれば calc_function は次のように修正しなければならないことが分かるだろう。

とかく境界の判断や更新は慎重に検討すべきである。

車輪を再発明する

「車輪を再発明する愚」という人がよくいるが, 再発明自体は大いによいことである。

ただし, そのための工数を確保するには, 説得力のある理由が必要である。

動作したという理由だけで満足しない

プログラムが動作したからといって完成したと思ってはいけない。

より汎用化できないか考える

汎用的なコードは, 再利用できる可能性が大きいため共通化が進み, プログラムの肥大化を防ぐことに繋がる。しかしより重要な利点は, 汎用的なコードからは特殊な要件が排除されるため, コードをシンプルに保ち, 品質を上げやすいというところにある。

具体的には, アルゴリズムやデータ構造を表現するコードから特殊な業務要件を分離し, パラメータや派生クラスとして実現することを考えるべきである。必要なら Facade を用意し, I/F をシンプルに保つ工夫も役に立つ。

前節で登場したバイナリサーチを汎用化してみよう。

この仕様は, 標準ライブラリの bsearch という関数ほとんどそのままである。車輪の再発明というわけである。

より簡単な方法がないか考える

動作するコードを書いてみて初めて, 設計フェーズでは気付かなかった抽象化や共通化の方法に気が付くことがある。書いたコードを目視確認していて複数回登場する似たようなパターンに気付いたり, I/F をよりシンプルにできることに気付いたりすることは決して珍しいことではない。

やや作為的だが, ここでは汎用バイナリサーチの仕様を少し変更し, 特定の値以上の最初の位置を返す lower_bound を実装してみる。 こちらの方が応用範囲は広がる。

バイナリサーチのコードの変数 hi の役割を微妙に変更している。バイナリサーチでは hi は対象範囲の最大インデックスを保持していたが, 今回の lower_bound では最大インデックス＋1 を保持している。

また, さらに作為的だがバイナリサーチもループ内が極力短くなるように少し変形してみる。ただし変数 hi の役割は元のままである。

こう変形してみると, 変数 hi の役割が違っているにもかかわらず, ループ部分のコードは lower_bound と全く同じコードとなった。実際にコードを書いてみる前にこのような事実に気付くのは難しい。

より効率化できないか考える

変数 lo, hi で対象範囲を絞込んでいくのではなく, 変数 lo と区間幅 n で対象範囲を絞り込んでいくことを考え, この 2 変数の動きを慎重に検討すると, else 節をなくすことができることが分かる。さらに変数 base と n で制御すればより簡単になるが JAVA ではできない。

乗算は, 加減算と比べると効率が悪いことが多い。工夫するとコードは長くなるがループ内から乗算を追い出すことができる。ここから先は C 専用の最適化を行っている。

さらに魂をこめる。(x & -x) という式で x のビットパターン中の最下位の 1 だけを取出すことができる。このことを利用すると, 上のコードの変数 n を省略することができる。

ややマニアックな話題だっただろうか。

主義主張を持つ

プログラミングスタイルを確立する

自分なりのプログラミングスタイルを確立するのは重要である。自分のスタイルで美しいコードには愛着が沸く。何より一定のポリシーに従ったプログラムコードは読みやすい。

プログラミング哲学に触れる

R. C. Martin らによってオブジェクト指向設計の原則がまとめられている。特に目新しい哲学とは言えないが, 設計の様々な段階でチェックリストとして用いると便利である。

魂を抜く

「一行入魂」を実践することはそれほど難しいことではないが, これが「万行入魂」とかになってくると, 必ずしもすべての行に同じ集中力で魂を込めるというのは現実的でなくなってくる。

イディオムを使いこなす

たとえば多くのプログラマは C++ や JAVA で n 回だけ繰返したいと思えば

というコードが特に考えなくても出てくるだろう。C/C++ でリスト構造を先頭から末尾まで辿りながら処理したいと思えば

である。この程度のコードならほとんど反射的にタイプする人もいる。

私の場合, その昔 i8080 系の CPU の全盛期に, アセンブリ言語で大量にコードを書いた経験があるが, このテの CPU はアドレッシングが貧弱で, 小さなテーブルルックアップだけでも次のようなコードを必要とした。しかし, この一連の流れはもう指が覚えてしまっていて, 最初のステップをタイプし始めながら, 6 ステップ先以降のコードを考えるというような芸当をこなしていた。高級言語の 1 ステップが数ステップから数十ステップにも膨らむアセンブリ言語で大量のコードを書くには, このような熟練はほとんど必須と言える。

いや, 今はもうほとんど覚えていない。

もちろんイディオムを構成する一連のコードは, 一度は魂を込めて考える必要がある。いわば一度込めた魂を再利用しているわけである。

メリハリを意識する

矛盾することを言うようだが, プログラム全体の中には密度が薄く, 再利用可能性をほとんど考える余地のないコードが大量に含まれることになる。魂を削って心血注ぐべきコードの割合が大きくなるようでは, あまりバランスのよいプログラム設計とは言えない。

設計書を妄信しない

設計者も間違う

信用しないと言うと語弊があるが, プログラマが渡された設計書は絶対的なものではないし, まして完全なものだと信じてはいけない。自分で納得できないプログラムは書くべきではない。プログラマはキーパンチャではないのだから。

設計へのフィードバック

私は昔物理学を勉強していたのだが, 物理学の根底には, 「正しい理論はシンプルであり, 数学的にも美しい理論である」という漠然とした信念がある。やたら前提条件が複雑であったり, 表現するのに複雑な数式が大量に必要であったりすると, その理論は別の大きな理論の一部を歪に切り取ったものなのではないか, とか, その理論をシンプルに表現できる数学が発明されるべきだと考えるわけである。

プログラムコードについても似たような考え方が成り立たなくもない。ある単純な処理を行うコードがむやみに複雑だったりした場合, 処理仕様が歪んでいるのではないのかとか, プログラミング言語や標準ライブラリに何か問題があるのではないかと疑ってみるのだ。

前者の場合, 処理仕様の改訂が提案できるような状況では大いに提案すべきである。

後者の場合, プログラミング言語の選定をやり直すというのは状況的に受入れられないことが多いが, たとえば非 OOP 言語で OOP の真似をする規約を提案するなど, 工夫によっては何とかなる可能性もある。

推薦図書

コメント追加

投稿者 Tomohiro Mochida : 2007/05/26 14:56:00 JST #

ADO.NETの基本

1. ADOとADO.NET

ADO とは，“ActiveX Data Object” の略であり，.NET 以前にデータベースにアクセスするための技術でした。ADO.NET は，この ADO をさらに進化させたものとなっています。

2. 構成

ADO.NET を構成するクラス群は，大きく2種類の部分に分けることができます。一つのグループは実際にデータベースシステムを操作するためのクラス群であり，もう一つのグループはデータを扱うためのモデルクラス群であるということができます。

前者はデータプロバイダと呼ばれていて，利用するデータベースシステムやドライバに応じていくつかのクラス群を選択して使用することになります。

後者は特に名前が付けられていないようですが，このクラス群の代表的クラスの DataSet の名前で呼ばれることがあるようです。この DataSet クラス群が，直接データベースに依存していない，つまりデータプロバイダと完全に分離されていることが，ADO.NET の大きな特徴となっています。この構成は非接続型アーキテクチャという言葉で呼ばれています。

次の図は，データプロバイダと DataSet の構造の概要を示しています。

上記以外にも，NET Framework の多くの GUI 部品は，ADO.NET と接続して簡単に GUI を構築するための機能を持っています。

3. データプロバイダ

標準のデータプロバイダには，以下の4種類があります。

・.NET Framework Data Provider for SQL Server

Microsoft SQL ServerのVersion 7.0 以降で利用するためのデータプロバイダです。このデータプロバイダは直接データベースシステムにアクセスするため，軽量かつ高速であるとされています。

名前空間は System.Data.SqlClient となっています。

・.NET Framework Data Provider for Oracle

Oracle クライアントを通じて Oracle にアクセスするためのデータプロバイダです。これは .NET Framework 1.1 になってから導入されました。

Oracle 自身も独自のデータプロバイダを配布しているため，Oracle を利用する場合はどちらかを選択することになります。

名前空間は System.Data.OracleClient となっています。

・NET Framework Data Provider for OLE DB

以前から利用されていた OLE DB を利用するためのデータプロバイダです。要するに OLE DB ブリッジです。OLE DB を経由して間接的にデータベースシステムにアクセスするため，上記のデータプロバイダと比べると効率が悪くなります。

名前空間は System.Data.OleDB です。

・.NET Framework Data Provider for ODBC

ODBC 経由でデータベースにアクセスするためのデータプロバイダです。.NET Framework 1.1 から標準となっています。

名前空間は System.Data.Odbc ですが，.NET Framework 1.0 で Microsoft の配布サイトからダウンロードして利用する場合は Microsoft.Data.Odbc となります。

4. 基本的なコード例

(1) 単純な SQL の実行

早速，SQL Server を例に，C# の簡単なコードを書いてみます。

 1: using System;
 2: using System.Data.SqlClient;
 3:
 4: public class SanCorporation
 5: {
 6:    public static void Main()
 7:    {
 8:        using (SqlConnection connection =
 9:               new SqlConnection("Data Source=.\\SQLEXPRESS; " +
10:                                 "Integrated Security=True; " +
11:                                 "Database=San"))
12:        {
13:            connection.Open();
14:            SqlCommand command =
15:                new SqlCommand("UPDATE bonus SET amount = amount * 2",
16:                               connection);
17:            command.ExecuteNonQuery();
18:        }
19:    }
20: }

DB 接続 (connection) の扱い方は C# の using 構文を使うと面倒が少なくてすみます (8～12, 18行)。SQL の実行は，コマンド (command) の生成と ExecuteNonQuery メソッドの実行のたった2ステップで完了してしまいます。

このようにパラメータを持たない，更新系の SQL は非常に簡単ですが，実際にはパラメータの定義とバインド，検索系であれば，取得結果の読み取りなど，もう少し複雑になるのが普通です。

(2) パラメータつき SQL の実行

次は，パラメータの例です。

 1: using System;
 2: using System.Data.SqlClient;
 3:
 4: public class SanCorporation
 5: {
 6:     public static void Main()
 7:     {
 8:         using (SqlConnection connection =
 9:                new SqlConnection("Data Source=.\\SQLEXPRESS; " +
10:                                  "Integrated Security=True; " +
11:                                  "Database=San"))
12:         {
13:             connection.Open();
14:             SqlCommand command =
15:                 new SqlCommand("UPDATE bonus SET amount = amount * @rate " +
16:                                "WHERE rank >= @rank",
17:                                connection);
18:             command.Parameters.Add("@rate", 3);  // .NET 2.0 では Add → AddWithValue
19:             command.Parameters.Add("@rank", 7);  // .NET 2.0 では Add → AddWithValue
20:             command.ExecuteNonQuery();
21:         }
22:     }
23: }

SQL に @変数名 の形でパラメータを埋め込んでおき，後に ParametersCollection を通じて値をセットしています (18～19行)。

(3) DataReader による結果の取得

検索系の SQL を発行し，データベースからデータを取得する方法として，大きく DataReader を用いて読み取る方法と，DataSet を用いる方法の二通りがあります。まずは DataReader を用いて取得する例です。

 1: using System;
 2: using System.Data.SqlClient;
 3:
 4: public class SanCorporation
 5: {
 6:     public static void Main()
 7:     {
 8:         using (SqlConnection connection =
 9:                new SqlConnection("Data Source=.\\SQLEXPRESS; " +
10:                                  "Integrated Security=True; " +
11:                                  "Database=San"))
12:         {
13:             connection.Open();
14:             SqlCommand command =
15:                 new SqlCommand("SELECT * FROM bonus WHERE amount >= 50000 " +
16:                                "ORDER BY amount DESC",
17:                                connection);
18:             SqlDataReader reader = command.ExecuteReader();
19:             while (reader.Read())
20:             {
21:                 Console.WriteLine("id=" + reader["id"] + ", " +
22:                                   "amount=" + reader["amount"]);
23:             }
24:             reader.Close();
25:         }
26:     }
27: }

上記例のように，DataReader を用いてデータを取得するには，コマンドの ExecuteReader メソッドによって SQL を発行します (18行)。また，Read メソッドによって1行1行読み進めながら，インデクサを用いて個々の値を取得することができます。

(4) DataSet による結果の取得

DataSet とデータベースの間でデータをやり取りするには，DataAdapter を用います。DataAdapter は，DataReader を使用して結果を読取り，DataSet にデータを充填するという処理を行います。

DataSet にも大きく2種類の使い方があります。ひとつは DataSet をそのまま利用する方法で，もうひとつは DataSet から専用のクラスを派生させて利用する方法です。前者を「型指定されていない DataSet」，後者を「型指定された DataSet」と呼びます。

型指定された DataSet は DataSet を派生した専用クラスですが，実際にプログラマがコーディングする必要はなく，Visual Studio のウィザードで簡単に作成することができるようになっています。今回は，もっぱら型指定されていない DataSet を使用しますが，コード例は後ほど示します。

(5) データプロバイダ依存のコーディングについて

ADO.NET のサンプルプログラムは，このセミナーで提示しているものも含めて，データプロバイダに依存するコードを多用しているものがほとんどです。が，少しの手間を惜しまなければ，汎用性を持たせることも可能です。そのためには，SqlCommand などの具象クラス名の代わりに System.Data 名前空間に用意されている，IDbCommand などのインターフェース名を使用してプログラムを記述します。ただし，.NET 2.0 以前はファクトリが用意されていなかったので，そこだけはプログラマが Abstract Factory パターンを応用するなどして何とかしなければなりませんでした。この欠点は .NET 2.0 では解消されています。(System.Data.DbProviderFactoryクラス)

ただし，プログラムコードを共通化しても，SQL やパラメータ名などの制約がデータベースシステム毎に異なりますので，結局は何らかの依存性が残ることになります。

・トランザクション

同一のデータを複数のプログラムあるいはオペレータが無秩序に操作すれば，さまざまな不都合が発生します。また，ある一連の操作を実行中にシステムがダウンした場合，データが矛盾した状態になってしまうことがあります。このような不都合が発生しないようにするためには，他のプログラムの影響を受けたくない一連の独立した処理単位を定義し，その実行中は他のプログラムを待ち合わせたり，いつシステムダウンしても，元に戻せるようなバックアップを残しておくなどの制御が必要となります。この独立した処理単位のことをトランザクションと呼びます。

たとえば，ある銀行の当座預金から普通預金に 100万円を移し変えるという処理を考えて見ます。この処理と前後して，ちょうど会社から給与20万円の振込の処理も発生したとしましょう。これを何の工夫もなしに行ってしまうと，たとえば次のような順序で処理が進むかも知れません。何が起こるか考えてみてください。

1. トランザクションとは

(1) ACID特性

トランザクションは，次の4つの特性を満たさなければならないとされています。

・原子性 (Atomicity)

トランザクションは，分割することができない処理単位です。トランザクションが成功したとき，含まれるすべての処理が成功したことになりますし，トランザクションが失敗したときは，すべての処理が一切行われていない状態になっています。途中まで成功した状態でトランザクションが終わることはできません。

・一貫性 (Consistency)

トランザクションの実行前も実行後も，データの整合性を保っていなければなりません。トランザクションの実行の前後で矛盾があってはならないということです。

・隔離性 (Isolation)

トランザクションは互いに他のトランザクションに影響を与えないということです。前述の例のようなことがあってはならないということです。

・持続性 (Durability)

トランザクションの結果は保存されなければなりません。トランザクションの完了後，いつのまにかトランザクションが取消されているなどということがあってはならないということです。

(2) ローカルトランザクションとグローバルトランザクション

通常，データベースシステムには自分自身の管理するデータに対するトランザクションを保証する仕組みを備えています。このような自分だけに限定したトランザクションのことをローカルトランザクションと呼ぶことがあります。

それに対して，たとえば銀行口座から引出す処理と，発注テーブルにレコードを挿入する処理を不可分に行いたいというような場合，複数のシステムにまたがったトランザクションが必要となります。このようなトランザクションをグローバルトランザクションと呼びます。

(3) プログラマティックなトランザクションと宣言的トランザクション

明示的トランザクションと暗黙的なトランザクションという言い方をすることもあります。

・プログラマティックなトランザクション

トランザクション制御の開始と終了をプログラムの処理として実行するという意味です。実際にコーディングするときは C# の using キーワードが役に立ちます。

・宣言的トランザクション

たとえば，このメソッドはトランザクションとして実行する，というような宣言に基づいて制御されるトランザクションのことです。トランザクションの設計からシームレスに実装に繋がるし，何よりトランザクションの終了し忘れなどを未然に防止することができるというメリットがあります。

2. データプロバイダのトランザクション

たとえば .NET Framework Data Provider for SQL Server の場合，SqlTransaction というクラスが用意されています。このオブジェクトを用いてトランザクション制御を行うことができますが，この場合，データベースシステム (SQL Server) のローカルトランザクションをプログラマティックに制御することになります。

3. EnterpriseServices (COM+)

.NET 以前から Windows には COM+ という仕組みが用意されており，VisualBasic などで宣言的トランザクションを利用することができました。.NET でもこの仕組みを利用することができ，「属性」でトランザクションを宣言することが可能です。

この方式には欠点もいくつかあります。

・この仕組みは MS DTC (Microsoft Distributed Transaction Coordinator) を利用しており，不必要に分散トランザクションが発生することがあります。このため，効率が低下しがちです。

・COM+ サービスを利用するためには，コンポーネント化が必須です。アセンブリを分離した上で，署名する必要があります。

ターゲットが Windows 2003 Server の場合は後者の欠点は克服することができます。Windows 2003 Server では，アプリケーションプログラムの一部をコンポーネントとして実行するという機能が使えます。この機能は System.EnterpriseServices.ServiceDomain クラスで制御することができます。ただし，この場合「宣言的なトランザクション」とは言えなくなります。

4. TransactionScope

.NET 2.0 の新機能として追加された仕組みです。この機能は，プログラマティックなトランザクションと宣言的トランザクションの中間的な制御，いわば宣言的トランザクションをプログラマティックに制御する機能となっています。また，ローカルトランザクションと分散トランザクションを適切に自動的に切り替える機能を持っています。

.NET 2.0 以降では，この機能以外は忘れてしまって構わないのではないかと思います。

トランザクションのスコープとして，次の3種類が用意されています。

・Required … このスコープには，トランザクションが必要です。アンビエント トランザクションが既に存在する場合は，アンビエント トランザクションを使用します。それ以外の場合は，スコープに入る前に新しいトランザクションが作成されます。これは既定値です。

・RequiresNew … スコープに対して，常に新しいトランザクションが作成されます。

・Suppress … スコープ内では，アンビエント トランザクションのコンテキストは抑制されます。スコープ内のすべての操作は，アンビエント トランザクションのコンテキストを使用せずに行われます。

コメント追加

投稿者 Tomohiro Mochida : 2006/07/01 14:53:00 JST #

 はじめに

　本資料は、株式会社アクシオン・ソフトウェアが主催するSAN(SaturdayActiveNetwork)で行う、勉強会用の資料である。 「エンタープライズアプリケーションアーキテクチャ入門」の書籍から、勉強会用にピックアップしたものになります。

対象読者としては、ビジネスアプリケーションに携わるプログラマ、設計者、およびアーキテクトとしている。　また、JavaやC#の知識があることが必要である。

本資料では、開発者が早期に確認したいと思っている決定事項やアプリケーションの主要となるパーツについて、パターンを通じて説明する。　また、エンタープライズアプリケーションとしているため、給与計算・診療記録・出荷管理・会計・顧客サービスなどのアプリケーションを対象とする。

アプリケーションアーキテクチャ

アーキテクチャは、システムを開発・存続していく上で、重要な要素である。　しかし、なかなか決定できない要素でもある。　アーキテクチャには少なくとも2つの要素があると考えられる。　1つは、システムから個々のパーツへブレークダウンできること、１つは、簡単には変更できない決定事項であるということである。　また、1つのシステムには、複数のアーキテクチャが存在してもよく、システムの存続期間中に変わることもありえる。

レイヤ化

レイヤ化は、ソフトウェアシステムの分割のために使用する一般的な技法である。

以下のようなメリットがある。

・      各レイヤは、その下位のレイヤについてのみ知っていればよく、さらにその下位のことは知らなくてもソフトウェアが構築できるのである。　たとえば、イーサネットの動作を知らなくても、TCPの上のFTPサービスを構築できる。

・      レイヤを入れ替えることも可能となり、柔軟なシステムを構築することができる。　たとえば、FTPサービスは、イーサネット・PPP・ケーブル会社が変わっても、実行に支障はない。

また、デメリットもある。

レイヤを追加するとパフォーマンスを損ねる可能性がある。

コメント追加

投稿者 Tomohiro Mochida : 2006/02/04 14:52:00 JST #

Common Language Infrastructure (CLI; 共通言語環境仕様)

言語に依存しない，ソフトウェアの実行環境を仕様化したもの。標準化されてヨーロッパ電子計算機工業会の規格である ECMA-335 となった。この仕様を Windows 上で実装したものが CLR である。

• CLS (共通言語仕様) は，言語に依らない型，命名規約，継承の仕組み，などを仕様として規定したもので，CLI の一部である。

共通言語ランタイム (CLR)

• IL コード仮想マシン，JIT を含む，実行時エンジン。
• ガベージコレクションを含むメモリ管理。
• 安全性への配慮。
• CTS (共通型システム) は，CLS のサブセットである。これは CLR が CLI の機能制限版なのではなく，CLS よりもゆるい制約に基づいたプログラムを許容するという意味で，機能拡張となっているとも言える。

クラスライブラリ

• Windows アプリケーション
• Web アプリケーション
• Web サービス

Mono

• Linux 等の UNIX 系 OS，および Windows をターゲットとする。
• オープンソース。
• C#，C，C++，Pascal，COBOL のサポートを目指している。

C# とは？

時代的には C→C++→Java→C# という流れであるが，C# は C++ と Java の中間的な機能を持っていると言われるようである。また，プロパティ，インデクサ，イベントやデリゲートなどといった，コンポーネント指向寄りの機能を備えているという点は，おそらく Visual Basic や Delphi の影響と思われる。

タイプセーフで，オブジェクト指向で，ガベージコレクションを持つという点は Java と同様であるが，COM (Active-X) などの既存のコンポーネントとの親和性では明らかに優れている。

Microsoft は，C# を .NET Framework の主力開発言語であると考えているらしい。

C# プログラミング概要

Hello World

伝統的な Hello, World は，C# では次のようになる。

1: // Hello World
2: class Hello
3: {
4:     static void Main()
5:     {
6:         System.Console.WriteLine("Hello, World.");
7:     }
8: }

コメント

｢//｣から行末まで, または｢/*｣から｢*/｣まではコメントである。

Main メソッド

プログラム内のどこかにプログラムの実行を開始から終了まで制御する Main メソッドを定義する必要がある。Main メソッドはクラス (class) または構造体 (struct) 内の静的 (static) なメソッドとして定義する。返値型は void または int, 引数は string[] または引数なしとすることができる。

// こんにちは、世界。
class Hello
{
    static int Main(string[] args)
    {
        System.Console.WriteLine("こんにちは、世界。");
        return 0;
    }
}

C や C++と違い，引数を string[] としたとき，プログラム名は渡されない。

返値型を int としたとき，Main メソッドが返した値はプログラムの終了ステータスとして扱われる。

入出力

入出力は通常 .NET Framework の機能を利用する。上例では，名前空間 System の Console クラスが持つ，WriteLine メソッドを利用することになる。

C# プログラムの構造

C#プログラムは 1 個以上のファイルからなる。各ファイルは 1 個以上の名前空間を含み, 各名前空間はクラス，構造体，インターフェース，列挙型，デリゲートといった型定義や，他の名前空間を含む。以下は，このすべてを含むファイルの例である。

// C#プログラムの骨組み
using System;

namespace MyNamespace1 
{
    class MyClass1 
    {
    }

    struct MyStruct 
    {
    }

    interface IMyInterface 
    {
    }

    delegate int MyDelegate();

    enum MyEnum 
    {
    }
 
    namespace MyNamespace2 
    {
    }

    class MyClass2 
    {
        public static void Main(string[] args) 
        {
        }
    }
}

C#プログラムの開始と終了

• Main メソッドは, プログラムのエントリポイントであり, プログラムの開始から終了までを制御する。
• Main メソッドは, クラスまたは構造体内の静的メソッドである。
• Main メソッドの返値型は void または int である。
• Main メソッドは引数を持たないか, または string[] 型の引数を持つ。
• Main メソッドが引数を持つ場合, 引数にはコマンドライン引数が渡される。
• プログラム名は引数として渡されない。

アセンブリとグローバルアセンブリキャッシュ

• アセンブリとは .NET Framework アプリケーションを構成する基本的な単位である。
• アセンブリにはメタデータと呼ばれる内部バージョン番号やデータ，型の情報が含まれている。
• アセンブリは，必要となった時点でロードされる。使用されないアセンブリはロードされない。
• アセンブリには複数のモジュールを含ませることができる。
• アセンブリは .EXE や .DLL として実現される。
• グローバルアセンブリキャッシュ (GAC) を用いて，アセンブリを他のアプリケーションと共有することができる。
• GAC へ配置するアセンブリは，厳密名を定義しなければならない。

データ型

データ型の概要

• int，char 等の組込みデータ型とクラス，構造体等のユーザ定義データ型がある。
• 値型と参照型がある。

組込みデータ型

ユーザ定義データ型

演算子

ボックス化 (boxing) とボックス化解除 (unboxing)

ボックス化とボックス化解除と呼ばれる機能は，値型を参照型として扱うための機能である。ボックス化とは，値型を参照型オブジェクトのインスタンスに詰込むことである。こうすることで値型はガーベージコレクションの対象となるヒープへコピーされる。逆にボックス化解除とはボックス化によって参照型オブジェクトに詰込まれた値型を取出すことである。

int i = 123;
object o = (object)i;        // ボックス化
o = 123;                     // ボックス化。特にキャストは必要ない。
i = (int)o;                  // ボックス化解除。キャストが必要。

ボックス化は単純な代入と比べて新しいオブジェクトを生成するなどの複雑な処理が必要であり，時間がかかる。ボックス化解除は，ボックス化ほどではないが，キャスト処理の分だけ単純な代入よりも時間がかかる。

名前空間

名前空間は，複数のクラスライブラリを同時に使用する場合などで，名前の衝突を防ぐための機能である。

名前空間のメンバにアクセスするには，using キーワードを使用して省略可能にするやり方と，明示的に名前空間を指定してアクセスするやり方がある。

using System;
...
Console.WriteLine("Hello, World");

System.Console.WriteLine("Hello, World");

using キーワードを使用して，名前空間の別名を宣言することもできる。

using com = System.Data.Common;
using sql = System.Data.SqlClient;
...
sql.SqlConnection cn = new sql.SqlConnection(...);
com.DbTransaction tx = cn.BeginTransaction();

名前空間を定義するには namespace キーワードを用いる。名前空間はネストすることができ，その場合 2 通りの書き方がある。

namespace N1
{

    // 名前空間 N1 のメンバ (クラスなど) の宣言

    namespace N2
    {
        // 名前空間 N1.N2 のメンバ
    }
}

namespace N1.N2
{
    // 名前空間 N1.N2 のメンバ
}

オブジェクトとクラス (class) と構造体 (struct)

C# はオブジェクト指向言語であり，ウィンドウやコントロールやデータ構造といったオブジェクトを表現するためにクラスや構造体を使うことになる。

• オブジェクトとは特定のデータ型の実体を言う。データタイプは実行時に生成されるオブジェクトの設計図である。
• クラスや構造体を利用して新しいデータ型を定義できる。
• クラスや構造体は C# アプリケーションのコードやデータを含む塊である。C# アプリケーションは常に最低でも 1 個のクラスを含んでいる。
• 構造体は特に小さなデータを格納するときには理想的な，手軽なクラスと考えられる。
• C# のクラスは継承をサポートする。すなわち，既存のクラスをベースに，新しい別のクラスを定義できる。

オブジェクト

オブジェクトとは，データ，振舞い，アイデンティティを持ったプログラミング上の構造である。オブジェクトのデータはフィールド，プロパティ，イベントに含まれ，オブジェクトの振舞いはメソッドとインターフェースで定義される。

オブジェクトがアイデンティティを持つとは，2 つのオブジェクトが全く同じデータを含んでいるからといって，必ずしも「同一」のオブジェクトとは見なされないということである。

C# ではクラスと構造体を通してオブジェクトを定義する。クラスと構造体は，その型のすべてのオブジェクトの役割の設計図を構成する。

• ウィンドウやコントロールを含めて，C# で扱うすべてのものはオブジェクトである。
• オブジェクトは，そのクラスや構造体によって定義された鋳型から実体化 (生成) される。
• オブジェクトが含む情報の取得や変更にはプロパティを使用する。
• オブジェクトの動作を表すためには，メソッドやイベントを使用する。
• あらゆる C# のオブジェクトは Object を継承する。

クラス (class)

クラスによってデータ型を定義することができる。クラスを定義すると，そのインスタンス (実体) を生成することが可能となる。クラスの実体を生成すると，その参照が返される。オブジェクトへ割当てられた変数には，オブジェクトのデータそのものではなく，このオブジェクトへの参照が格納される。オブジェクトへの参照は，複数の変数へコピーすることができるが，コピーされた参照はすべて元の同一のオブジェクトを表現することになる。このようなわけでクラスは「参照型」であるという。すべての参照型は System.Object から派生する。

クラスはキーワード class を使って定義する。

public class MyClass : MyBaseClass
{
    // メソッド，プロパティ，フィールド，イベントの定義
}

上例で，クラスの名前が「MyClass」であること，アクセスレベルが public であること，基底クラス MyBaseClass から派生していること，を定義している。アクセスレベルが public であるというのは，どこからでもこのクラスを指定することができることを意味している。基底クラスが MyBaseClass から派生しているとは，基底クラス MyBaseClass のすべてのメンバ (メソッド，プロパティ，フィールド，イベント) を派生クラス MyClass も受継いで持っていることを意味する。この機能のことを「継承」という。基底クラスもまた基底クラスを持てるため，一つのクラスには基底クラスがいくつでもあり得る。派生クラスのオブジェクトは基底クラスのオブジェクトの性質をすべて受継いでいるため，派生クラスのオブジェクトは基底クラスのオブジェクトとして使用することができる。このため，派生クラスへの参照は，基底クラスへの参照へ変換できるようになっている。

基底クラスを指定せずにクラスを定義すると，暗黙のうちに基底クラスが System.Object となる。あらゆるクラスは，その基底クラスを遡って行くと最後には System.Object を基底クラスとして持っている。したがって，すべてのクラスオブジェクトは，System.Object 型であるとして扱うことができる。

public class MyPersonClass
{
    // フィールド
    private string name;
    // コンストラクタ
    public MyPersonClass()
    {
        name = "unknown";
    }
    // メソッド
    public void SetName(string newName)
    {
        name = newName;
    }
}

上例は，フィールドとコンストラクタとメソッドをそれぞれ 1 個ずつ持つパブリックなクラスの例である。このクラスのオブジェクトは次のように new キーワードを用いて生成し，使用できる。

MyPersonClass person1 = new MyPersonClass();
person1.SetName("尚遠");

クラスの概要

• クラスは参照型である。
• 単一継承のみをサポートしている。(Java と同様。C++ は多重継承をサポートしている。) つまり，直接の基底クラスは 1 個だけに限定される。
• インターフェースはいくつでも実装できる。
• クラス定義は，複数のファイルに分割して記述できる。(C# 2.0)
• 静的なクラスは，静的なメンバのみを持つ。(C# 2.0)

構造体 (struct)

構造体はキーワード struct を使用して定義する。

public struct MyStruct
{
    // フィールド，プロパティ，メソッド，イベントの定義
}

構造体定義の構文は，クラス定義の場合とほとんど同様であるが，クラスにはない制限がある。

• インスタンスフィールドの宣言に初期化子は書けない。ただし静的フィールドには初期化子が書ける。
• デフォルトコンストラクタ (引数なしのコンストラクタ) およびデストラクタを宣言できない。

コンパイラが自動的に生成するデフォルトコンストラクタは，構造体が含むすべてのフィールドをデフォルト構築する。構造体はクラスや他の構造体から派生することはできない。

構造体は値型である。構造体のオブジェクトを生成し，変数へ代入すると，構造体の実体が変数へと格納される。変数をコピーすると構造体自身がコピーされ，コピー元オブジェクトとコピー先オブジェクトの一方に対する変更は他方には影響を与えない。構造体はアイデンティティを持たない。構造体への参照を扱う手段はないため，全く同じ値を持つ構造体同士を区別する手段もないからである。C# のすべての値型は，System.ValueType を継承する。System.ValueType は System.Object を継承する。

値型は参照型へいつでも変換 (ボックス化) できる。

構造体の概要

• 構造体は値型である。(クラスは参照型である。)
• 構造体をメソッドの引数として渡す場合はその参照ではなく値が渡される。
• クラスとは異なり，構造体を実体化するのに new 演算子は必要ない。
• 構造体にはコンストラクタを宣言できるが，必ず引数を持たなければならない。
• 構造体は他の構造体やクラスからは派生できないし，構造体からクラスを派生することもできない。すべての構造体は System.ValueType を直接継承し，System.ValueType は System.Object を継承している。
• 構造体はインターフェースを実装できる。
• インスタンスフィールドの初期化子は書けない。

構造体の使用方法

構造体は「位置」，「長方形」や「色」といった，小さなオブジェクトを表現するのに適している。このような，オブジェクトをクラスを用いて表現することもできるが，しばしば構造体の方が効率がよくなる。たとえば，「位置」クラスの 1000 個のオブジェクトからなる配列を生成する場合，各位置オブジェクトのためにメモリを確保することになる。

public struct Point
{
    public int x;
    public int y;

    public Point(int p1, int p2)
    {
        x = p1;
        y = p2;
    }
}

構造体にはデフォルトコンストラクタ (引数を持たないコンストラクタ) は定義できない。デフォルトコンストラクタはコンパイラが勝手に用意し，常にすべてのメンバをデフォルト値で初期化する。また，インスタンスフィールドを初期化子で初期化することもできない。

構造体を new 演算子で生成すると，適切なコンストラクタを使用して初期化することができる。クラスとは違い，new 演算子を使わずに生成することができるが，この場合は構造体は初期化されず，すべてのメンバを明示的に初期化するまでは参照できないことになる。

構造体はクラスと違って継承を利用できない。構造体は他の構造体やクラスから派生させることはできないし，クラスの基底クラスとすることもできない。しかしながら，構造体は Object を継承しているし，クラスと同様にインターフェースを実装することもできる。

C++ とは違って，struct キーワードを使いクラスを宣言することはできない。C# では，クラスと構造体は本質的に異なるものである。構造体は値型であるがクラスは参照型である。

参照型が必要な場面はともかく，小さなクラスは構造体で置き換えることで効率が良くなることがある。

例

using System;
public struct Point
{
    public int x, y;

    public Point(int p1, int p2)
    {
        x = p1;
        y = p2;
    }
}

class MainClass
{
    public static void Main()
    {
        Point myPoiont = new Point();
        Point yourPoint = new Point(10, 10);
        Point hisPoiont;

        hisPoint.x = 20;
        hisPoint.y = 20;

        Console.Write("My Point:    ");
        Console.WriteLine("x = {0}, y = {1}", myPoint.x, myPoint.y);
        Console.Write("Your Point:  ");
        Console.WriteLine("x = {0}, y = {1}", yourPoint.x, yourPoint.y);
        Console.Write("His Point:   ");
        Console.WriteLine("x = {0}, y = {1}", hisPoint.x, hisPoint.y);
    }
}

My Point:    x = 0, y = 0
Your Point:  x = 10, y = 10
His point:   x = 20, y = 20

上例で, myPoint はデフォルトコンストラクタによって, yourPoint は宣言したコンストラクタによって, それぞれ初期化し, hisPoint はメンバ毎に初期化している。

クラスおよび構造体のメンバ

クラスおよび構造体のオブジェクトの持つデータや振舞いを定義するメンバとしては，以下のものがある。

• メソッド
• コンストラクタ
• デストラクタ
• プロパティ
• フィールドと定数
• インデクサ
• 型 (クラスや構造体など)

クラスおよび構造体のメソッド

C# では，クラスと構造体のメソッドはオブジェクトの動きを定義する。メソッドは本質的には一連の文を含むコードブロックである。メソッドは値を計算し，オブジェクトデータに対する操作を実行し，オブジェクトデータに基づく動作を実行するのに利用される。またこれだけにとどまらず，メソッドは C# 言語で表現できるどんな操作も実行することができる。

メソッドは，クラスブロックの中でアクセスレベル，戻り値の型，メソッド名，それにもしあればメソッドパラメータの型と名前を指定することによって宣言される。メソッド引数は，括弧で囲み，カンマで区切られる。空の括弧は，メソッド引数がないことを示す。

class MyClass
{
    void MyMethod1() {}
    void MyMethod2(int param1) {}
    int MyMethod3(int param1, int param2) {}
}

特定のオブジェクトについてメソッドを呼出すのは，フィールドにアクセスする方法と似ている。オブジェクト名の後にドット，メソッド名，それに括弧で引数を書けばよい。

MyClass myObj = new MyClass();

int MyNumber1 = 1;
int MyNumber2 = 2;

// メソッドの呼出し
myObj.MyMethod1();
myObj.MyMethod2(MyNumber1);
myObj.MyMethod3(MyNumber1, MyNumber2);

メソッド引数

メソッドパラメタはメソッドのブロックの中で利用可能である。デフォルトでは，メソッドパラメタはメソッドを呼出す側によって渡されたオブジェクトのコピーである。つまり，パラメタへの変更は，呼出し元のオブジェクトに反映されない。メソッドのコードブロックでは，パラメタだけでなく，同じクラスで定義された他のメソッド，フィールド，プロパティ，イベントに，直接アクセスすることができる。

class MyClass
{
    int myInt;

    void MyMethod1(int param1)
    {
        myInt = param1;
    }

    void MyMethod2(int myInt)
    {
        this.myInt = myInt;
    }
}

クラスのメンバとパラメタを明示的に区別するには，現在のインスタンスを示す this キーワードが使用できる。上例の MyMethod2 がその例である。このようにパラメタ名がメンバ名と同じ場合に利用できる。

メソッドは値を呼出し元に返すことができる。戻り値型 (メソッド名の前に指定する型) が void でない場合，メソッドは return キーワードを使用することで値を返すことができる。キーワード return の後に戻り値型に適合する値を続ければその値が返され，メソッドの実行はそこで終了する。戻り値型が void であっても，値のない return 文をメソッドの実行を終了させるために利用できる。個の場合，return キーワードがなくても，コードブロックの終端に達すると，メソッドの実行は終了する。一方，void 以外の戻り値型のメソッドは，値を返すために必ず return キーワードを使用する必要がある。

class MyClass
{
    int AddTwoNumbers(int param1, int param2)
    {
        return param1 + param2;
    }

    void MyMethod2(int param)
    {
        System.Console.WriteLine(param);
        // 戻り値型が void であるため, return は不要
    }
}

呼出し元は，その型の値が利用できるどこにでもメソッド呼出しを記述できる。

MyClass myObj = new MyClass();

int result = myObj.AddTwoNumbers(1, 2);     // 戻り値を result に格納
myObj.MyMethod(result);                     // 別のメソッドの引数として渡す

myObj.MyMethod(myObj.AddTwoNumbers(1, 2));  // このように使うこともできる

仲介役の変数を用いて複雑な式を読みやすい単純な式に変形することができる。また，メソッドの戻り値を複数回利用する場合には，必要となることもある。

メソッドパラメータで使用するキーワード

ref，out，param の 3 つのキーワードはメソッドパラメータの振舞いを変えるために用意されている。

デフォルトでは，メソッドに渡されるパラメータ値はコピーであり，メソッド本体での変更は呼出し元には影響を与えない。パラメータが値型 (構造体) の場合，メソッド側が変更した構造体の値を呼出し元が利用する手段はない。パラメータが参照型 (クラス) の場合，パラメータはオブジェクトの実体ではなく，オブジェクト実体への参照であるため，メソッドが変更したオブジェクトの実体を，呼出し元から利用することは可能である。しかしながら，別のオブジェクトへの参照をパラメータに代入するなどのパラメータ自体の変更は，値型のときと同様に呼出し元には影響を与えない。

パラメータに ref キーワードを適用することで，パラメータ値をコピーせずに直接渡し，メソッドの実行が終了する際に，呼出し元に戻すように指示することができる。つまり，メソッド側で変更した後のパラメータを，呼出し元が利用できることになる。ref キーワードはメソッドの宣言時と，そのメソッドを呼出すときに使用する。

class SwapSample
{
    static void SwapInts(ref int i, ref int j)
    {
        int t = i;
        i = j;
        j = t;
    }

    public static void Main()
    {
        int a = 123;
        int b = 456;
        System.Console.WriteLine("SwapInts 実行前: {0} {1}", a, b);
        SwapInts(ref a, ref b);                                     // ref を使用して呼出す
        System.Console.WriteLine("SwapInts 実行後: {0} {1}", a, b);
    }
}

out キーワードは，パラメータがデータを呼出し元へ返すためのパラメータであることを示す。呼出し元はパラメータを指定し，メソッドがそのパラメータに新しい値を代入することになる。out パラメータは 1 つ以上の値を返す必要があるメソッドに使用する。ref パラメータとは異なり，out パラメータの初期値をメソッド側で使用することはできない。out キーワードはメソッドの宣言時，そのメソッドの呼出し時に使用する。

class DivideSample
{
    static int DivMod(int dividend, int divisor, out int modulo)
    {
        modulo = dividend % divisor;
        return dividend / divisor;
    }

    public static void Main()
    {
        int quo;
        int mod;
        quo = DivMod(7, 3, out mod);                                // out を使用して呼出す
        System.Console.WriteLine("7 ÷ 3 = {0} ... {1}", quo, mod);
    }
}

param キーワードはパラメータ配列を作成する際に用いる。パラメータ配列は，メソッドの最後の 1 次元配列型のパラメータでなければならない。呼出し元は，パラメータ配列を 2 通りの方法で利用することができる。すなわち，最後のパラメータとして配列型を渡すこともできるし，配列の要素型として扱える一連のパラメータを渡すこともできる。パラメータを渡さないことも可能である。

class Summary
{
    static int Sum(params int[] list)
    {
        int sum = 0;
        for (int k = 0; k < list.Length; ++k)
            sum += list[k];
        return sum;
    }

    public static void Main()
    {
        int sum = Sum(1, 2, 3);                           // 3 個の引数
        System.Console.WriteLine("1 + 2 + 3 = {0}", sum);
        int[] data = {4, 3, 2};
        sum = Sum(data);                                  // 1 個の配列
        System.Console.WriteLine("4 + 3 + 2 = {0}", sum);
        sum = Sum();                                      // 引数なし
        System.Console.WriteLine("          = {0}", sum);
    }
}

メソッドの修飾子

アクセスレベルは，public，private，protected，internal，protected internal のいずれかである。

以下にその他の修飾子を挙げる。

コンストラクタ

コンストラクタは，クラスまたは構造体名を名前とする特殊なメソッドである。

インスタンスコンストラクタは，new キーワードを用いてインスタンスを生成する際，オブジェクトの実体を生成した直後に呼出される。インスタンスコンストラクタの主な役割は，インスタンスの初期化である。引数を持たないインスタンスコンストラクタをデフォルトコンストラクタという。

また，静的 (static) コンストラクタは，プログラムの実行時，クラスが最初にアクセスされる前に呼出される特殊なメソッドである。静的コンストラクタの呼出しを制御する方法は用意されていない。

デストラクタ

C# はガベージコレクションをサポートしている。ガベージコレクションとは，生成したオブジェクトが必要なくなったときに特に意識してオブジェクトを解放しなくても，自動的に不要なオブジェクトを検出して解放する仕組みのことである。しかし，リソースの獲得と解放について気をつけなければならないケースも存在する。デストラクタはそのような場合に役に立つことがある。

• デストラクタは構造体にはない。デストラクタが利用できるのはクラスに対してのみである。
• 1 つのクラスは 1 つまでしかデストラクタを持てない。
• デストラクタは継承したりオーバロードしたりできない。
• デストラクタは自動的に呼出される。明示的に呼出すことはできない。
• デストラクタは修飾子やパラメータを持てない。

プロパティ

プロパティは，クラスや構造体の保持する情報にアクセスする際に利用する。フィールドに直接アクセスするよりも柔軟で安全である。

class Rectangle
{
    private double width;

    public double Width
    {
        get
        {
            return width;
        }
        set
        {
            if (value < 0)
                throw new System.ArgumentException("負の幅を設定しようとした");
            width = value;
        }
    }

    public double Height;

    public double Area
    {
        get
        {
            return width * Height;
        }
    }
}

class MyMain
{
    Rectangle r = new Rectangel();
    r.Width = 6;                         // Width プロパティにアクセス
    r.Height = 7;                        // Height はフィールドを直接アクセス
    System.Console.WriteLine("Area = {0}", r.Area);

    try
    {
        r.Width = -3;                    // Width プロパティに不正な値を入れてみる
    }
    catch (System.ArgumentException)
    {
    }
}

インデクサ

インデクサは，クラスや構造体を配列のようにインデックスで参照するための機能である。インデクサはプロパティと同様の機能であるが，パラメータを持つところが異なっている。

class IntCollection
{
    private int[] myArray = new int[100];

    public int this[int i]
    {
        get
        {
            return myArray[i];
        }
        set
        {
            myArray[i] = value;      // セットする値は「value」で参照できる
        }
    }
}

class MyMain
{
    public static void Main()
    {
        IntCollection c = new IntCollection();
        c[0] = 1;
        c[1] = 2;
        System.Console.WriteLine("{0} {1}", c[0], c[1]);
    }
}

• オブジェクトを配列のようにインデックスしてアクセスするために用いる。
• get インデクサは値を返す。set インデクサは値を代入する。
• インデクサのコードは this キーワードを使用したブロック内に記述する。
• set インデクサで設定する値は value キーワードで参照する。
• インデクサは必ずしも整数でインデックスする必要はない。
• インデクサはオーバロードできる。
• インデクサは多次元にもできる。たとえば 2 次元配列のようにアクセスできるインデクサも可能である。

class DayCollection
{
    string[] days = {"Sunday", "Monday", "Tuesday", "Wednesday",
                     "Thursday", "Friday", "Saturday"};

    // 曜日の名前を探し，0～6 または -1 を返す。
    private int getday(string testday)
    {
        // 馬鹿サーチ
        int i = 0;
        foreach (string day in days)
        {
            if (day == testday) return i;
            i++;
        }
        return -1;
    }

    // 日曜日～土曜日を 0～6 にして返すインデクサ (読出しのみ)
    public int this[string day]
    {
        get
        {
            return (getday(day));
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        DayCollection week = new DayCollection();
        Console.WriteLine(week["Friday"]);
        Console.WriteLine(week["Made-up Day"]);
    }
}

配列

配列は同じ型の変数の並びを表現するデータ構造である。配列には 1 次元配列，多次元配列，配列の配列 (jagged 配列) がある。

// 1 次元配列の生成と使用
int[] myIntArray1 = new int[3];
myIntArray1[0] = 1;
myIntArray1[1] = 2;
myIntArray1[2] = 3;

// 1 次元配列を生成し，同時に初期化
int[] myIntArray2 = new int[3]{ 1, 2, 3 };
// 上のコードと全く同じ省略形
int[] myIntArray3 = { 1, 2, 3 };

// 2 次元配列の生成と使用
int[,] myMultidimensionalArray1 = new int[2, 3];
// 同時に初期化
int[,] myMultidimensionalArray2 = { { 1, 2, 3 }, { 4, 5, 6 } };

// jagged 配列
int[][] myJaggedArray = new int[3][];
// jagged 配列の最初の要素 (これは 1 次元配列) を生成
myJaggedArray[0] = new int[4] { 1, 2, 3, 4 };

• 配列には 1 次元，多次元，jagged の種類がある。
• 配列の要素は配列を生成した直後は数値型であればすべて 0，参照型であれば null となる。
• jagged 配列は，配列の配列である。配列は参照型であるため，jagged 配列の生成直後はすべての要素が null である。
• 配列のインデックスは常に 0 から始まる。したがって要素数が n であれば，インデックスは 0 ～ n-1 の範囲となる。
• 配列要素の型は，値型でも参照型でも良い。配列型でも良い。
• 配列は System.Array から派生する参照型である。

継承

クラスは別のクラスを継承して定義することができる。継承はクラス宣言のクラス名の後ろに「:」に続けて継承したいクラス (基底クラス) 名を記述することで表現する。

public class MyBaseClass
{
    int a;

    public MyBaseClass() {}
    public void DoSomething() { ... }
}

public class MyDerivedClass: MyBaseClass
{
    int b;

    public MyDerivedClass() {}
    public void DoAnother() { ... }
}

上例では MyBaseClass から派生する MyDerivedClass を定義している。派生して定義したクラスを元のクラスの派生クラス，元のクラスを派生クラスの基底クラスという。

派生クラスは，通常基底クラスのすべての性質 (データや動作) を受継ぎ，さらに基底クラスにはない独自の性質を持つことができる。派生クラスは基底クラスとしての性質も兼ね備えているため，基底クラスとして振舞うことができる。このことから，派生クラスのオブジェクトは，基底クラス型として参照することができる。逆に，派生クラスのオブジェクトを参照している基底クラス型の参照は，キャストによって元の派生クラス型の参照に変換することができる。キャストされた基底クラス型の参照が実際に派生クラスのオブジェクトを参照していなかった場合は，キャストは失敗し，System.InvalidCastException が発生する。

MyBaseClass x = new MyDerivedClass();
x.DoSomething();

MyDerivedClass y = (MyDerivedClass)x;

x = new MyBaseClass();
y = (MyDerivedClass)x;                  // InvalidCastExceptioin 発生!

基底クラス型の変数に代入して型変換したからといって，派生クラスの実体が変更されるわけではない。一旦派生クラスのインスタンスとして生成された実体は，不要になって破棄されるまで常に派生クラスのインスタンスとしてのアイデンティティを保ち続ける。

ポリモーフィズム

ポリモーフィズムとは，日本語では多態性または多形性とよばれる概念である。広い意味では，一見同一のコードが，さまざまな意味を持つことを言う。たとえば「x = a + b;」というコードは，a と b が数値型なら「加算」を意味しているが，a と b が文字列型であれば「連結」を意味すというのも，広い意味ではポリモーフィズムである。

一番狭い意味では，オブジェクトの共通のインターフェースを通して処理する手続きが，実行時に確定する実際のオブジェクトの性質によって，多様な動作を行うことができることを言う。

 1: // 抽象図形クラス
 2: class abstract Shape
 3: {
 4:     double positionX;  // 位置 X
 5:     double positionY;  // 位置 Y
 6: 
 7:     // この図形の位置を変更する (移動する)
 8:     void MoveTo(double x, double y)
 9:     {
10:         positionX = x;
11:         positionY = y;
12:     }
13: 
14:     // この図形の面積を計算して返す
15:     abstract double CalcArea();
16: }
17: 
18: // 正方形クラス
19: class Square : Shape
20: {
21:     double side;     // 辺の長さ
22: 
23:     Square( ... ) { ... }
24: 
25:     override double CalcArea()
26:     {
27:         return side * side;
28:     }
29: }
30: 
31: // 長方形クラス
32: class Rectangle : Shape
33: {
34:     double sideA;     // 一辺の長さ
35:     double sideB;     // 他の辺の長さ
36: 
37:     Rectangle( ... ) { ... }
38: 
39:     override double CalcArea()
40:     {
41:         return sideA * sideB;
42:     }
43: }
44: 
45: // 複数の図形集合をひとつの図形として扱う図形
46: class MultiShape : Shape
47: {
48:     Shape[] shapes;
49: 
50:     MultiShape( ... ) { ... }
51: 
52:     override double CalcArea()
53:     {
54:         // すべての図形の総面積を求める
55:         double totalArea = 0;
56:         foreach (Shape shape in shapes)
57:             // この単純なコードは，実はさまざまなメソッドを呼び分ける
58:             totalArea += shape.CalcArea();
59:         return totalArea;
60:     }
61: }
62: 
63: class Canvas
64: {
65:     Shape[] shapes;
66: 
67:     void SomeMethod()
68:     {
69:         ...
70:         foreach (Shape shape in shapes)
71:         {
72:             ...
73:             // このコードは常に Shape クラスの MoveTo メソッドを呼出す
74:             shapes.MoveTo(x, y);
75:             ...
76:         }
77:     }
78: }

インターフェース

インターフェースは，オブジェクトの使われ方のみを定義し，オブジェクトが具体的に持つデータや，動作については関知しない。データや動作はインターフェースを実装するクラスや構造体に完全に任される。

C# は単一継承だけをサポートしているが，実装するインターフェースについては制限がないため，複数の基底クラスから継承する代わりにインターフェースを利用することもある。

デリゲート

C# のデリゲートは，C や C++ の関数ポインタと同じようなものである。デリゲートを使用すると，メソッドへの参照を抽象化でき，実際に呼出されるメソッドを動的に選択することができる。

 1: delegate void MyDelegate(string s);
 2:
 3: class YourClass
 4: {
 5:     public string x;
 6:     public void YourMethod(string s)
 7:     {
 8:         System.Console.WriteLine("YourClass {0}: {1}", x, s);
 9:     }
10: }
11:
12: class MyClass
13: {
14:     static void MyMethod(string s)
15:     {
16:         System.Console.WriteLine("MyClass: {0}", s);
17:     }
18: 
19:     public static void Main()
20:     {
21:         YourClass a = new YourClass();
22:         a.x = "A";
23:         MyDelegate d = new MyDelegate(a.YourMethod);
24:         d("Hello");                             // YourClass A: Hello
25:         d = new MyDelegate(MyMethod);
26:         d("Yahoo");                             // MyClass: Yahoo
27:     }
28: }

上例で，YourClass の YourMethod を呼出す際は YourClass のインスタンスが必要である。デリゲートは，メソッドのコードの位置情報だけでなく，インスタンスの情報も格納されていることが分かる。

デリゲートはイベントと組合わせて利用することが多い。

イベント

C# のイベントは，コンポーネントが検出した特定の事象を，クライアントに通知するための機能である。たとえば GUI のボタンコンポーネントは，ボタンが押されたときに何をすれば良いのか分からないため，ボタンが押されたことをクライアントに通知し，処理を委譲する必要がある。その場合，C# ではボタンが押されたことを通知するためのデリゲート型を宣言し，クライアントはイベントにそのデリゲートのインスタンスを登録するという方法を取ることを想定している。

delegate void ButtonClickedEventHandler(object sender, EventArgs e);

class Button
{
    event ButtonClickedHandler Clicked;

    void OnClick(EventArgs e)
    {
        if (Clicked != null)
            Clicked(this, e);
    }

    ... いろいろ ....
}

class Client // 画面アプリケーション
{
    Button cancelButton;

    Client()
    {
        cancelButton = new Button();
        // ボタンのイベントに処理メソッドを接続
        cancelButton.Clicked += new ButtonClickedEventHandler(OnCancel);
    }

    void OnCancel(object sender, EventArgs e)
    {
        ... キャンセル処理を実行する ...
    }
}

安全でないコードとポインタ

C# では，unsafe コンテキストを使用して，ポインタを扱うことができる。

• OS の API や既存の COM などを利用する場合に必要となることがある。
• C# コンパイラの unsafe を許可するオプションスイッチを指定しないと，unsafe は使用できない。
• unsafe を利用して作成したアセンブリは「安全でない」と見なされ，インターネットから直接実行することはできなくなる。

nullable 型 (C# 2.0)

ある型に基づく nullable 型の変数は, 元の型のすべての値に加えて｢空値｣を表現することができる。この機能は特にデータベースを扱う際など, 保持するべき値がないもしくは存在しないことがあるような状況で有用である。

// nullable 型の例
int? x;
...
if (x != null)
    Console.WriteLine(x.Value);
else
    Console.WriteLine("未定義");

• 未定義状態を持つ変数を生成する際に用いることができる。
• 「T?」は「System.Nullable<T>」の省略形である。(Tは何らかのデータ型)
• HasValue プロパティは，変数が値を保持しているとき true，null であるとき false を返す。
• Value プロパティは，変数が値を保持しているときその値を返す。変数が値を保持していなければ，System.InvalidOperationException を投げる。
• nullable 型の変数のデフォルト状態は HasValue が false を返す状態である。

nullable 型の使用方法

nullable 型は，元の型のすべての値に加えて｢空値｣を表現することができる。その宣言には 2 通りの書き方がある。「T」が元の型とすると，

System.Nullable<T> 変数名

または

T? 変数名

のどちらの表現も同じ意味である。

nullable 型の例

値型なら何でも，それを元の型とした nullable 型を作成できる。

int? i = 10;
double? x = 3.14;
bool? flag = null;
char? letter = 'a';
int?[] myArray = new int?[10];

値型でない型は nullable 型にできない。

string? message = "Hello, World!";    // コンパイルエラー。string は参照型
MyClass? myInstance = new MyClass();  // コンパイルエラー。クラスは参照型

as 演算子は参照型にしか使用できないため，nullable 型と共に利用することはできない。

int a = 5;
object b = a;
int? c = b as int;                    // コンパイルエラー。int は値型

nullable 型のメンバ

型変換

int? x = null;
int y = x;         // コンパイルエラー

int y = (int)x;    // 元の型にキャストできる。しかし x == null の場合は例外が発生する
int y = x.Value;   // OK。しかし x == null の場合は例外が発生する

x = null;          // OK。null はいつでもセットできる。
x = 10;            // OK。元の型の値は，nullable 型に暗黙のうちに変換できる

演算

元の型に対する演算は，nullable 型に対しても適用できる。ただし null 値に対する演算は結果も null となる。(bool 型については特別)

int? x = 10;
x++;                             // x は 11 となる
x = x * 10;                      // x は 110 となる
int? y = null;
x = x + y;                       // x は null となる

nullable 型の比較については注意が必要である。nullable 型が null であるときの大小比較は，常に false となる。つまり，nullable 型の大小比較が false であった場合に，必ずしも逆の大小関係が成り立っているとは限らない。

int? x = null;
if (x >= 3)
    Console.WriteLine("x は 3 以上です。");
else
    Console.WriteLine("x は 3 未満です。");     // ウソ

null 値テスト

これまでの例に何度も見てきたとおり，HasValue プロパティを調べる方法と，null と等値比較する方法が使える。

int? x = 10;
if (x.HasValue) Console.WriteLine("x は値を保持しています。");

int? y = null;
if (y != null) Console.WriteLine("y は値を保持しています。");

?? 演算子

nullable 型の既定値を与えたいとき ?? 演算子が利用できる。

int? x = null;
int i = x ?? -1;    // i に x の値を設定する。ただし，x が null なら，-1 を設定する

int? y = 10;
int? z = x ?? y;    // z に x の値を設定する。ただし，x が null なら，y を設定する

bool?

bool? 型に関する & および | 演算は，やや特殊な規則となっている。

• 文と式と演算子
• 新デリゲート (C# 2.0)
• イテレータ (C# 2.0)
• ジェネリクス (C# 2.0)
• リフレクション
• 属性
• スレッド
• インタオペラビリティ
• XML コードコメント
• アプリケーションドメイン
• セキュリティ
• パフォーマンス
• クラスライブラリ
• Visual Studio (Windows Forms，Web サービス，Web アプリケーション)
• 他

コメント追加

投稿者 Tomohiro Mochida : 2006/01/14 14:43:00 JST #