【Visual Studio】開発画面構成の覚え書き【WPF】

開発画面の構成についてわかっている範囲で説明します。

※説明に使用している言葉については、いろいろなサイトから流用してはいるのですが自分自身が正式な名称を知らないため間違いがある可能性がありますのでご了承ください。

画面の配置

  1. 編集画面:GUIの操作でコンポーネントの配置などを行うことができます。
  2. ソリューションエクスプローラ:開発に必要なファイルをツリー構造で表示・選択することができます。
  3. XAML(WPFの画面定義):WPFは画面定義をXML形式で管理しております。このXMLを編集する画面になります。(編集画面、プロパティで操作した結果も反映されます。)
  4. プロパティ:編集画面で選択しているコンポーネントの設定を表示・変更できます。

ツールボックス

左側の「ツールボックス」タブをクリックすることでツールボックスが表示されます。

ツールボックスから配置するコンポーネントをドラッグアンドドロップで編集画面へ配置します。

下記画像は「ボタン」をドラッグアンドドロップした状態です。

編集画面とXAMLに反映されます。

 

【Visual Studio】新規プロジェクト作成【WPF】

会社に新入社員が入社してツールの使い方の説明も必要だなと思い、Visual StudioのWPFプロジェクトを作成するまでを書きます。

ダウンロード

まずは、MicrosoftのページからVisual Studioをダウンロードします。

※Microsoft Edgeで実行した画面キャプチャーになります。

https://www.visualstudio.com/ja/downloads/

「保存」を選択します。

ダウンロードを実行した時点でのバージョンは下記の通りでした。

vs_community__481173091.1523791801.exe

インストール

ダウンロードしたファイルを実行します。

起動した画面で「続行」ボタンを押下します。

以下の画面が表示されるので終了するまで待ちます。

以下の画面が表示されたら「インストール」ボタンを押下します。

ワークロードの「.NET デスクトップ開発」を選択し、「場所」にインストール先のフォルダーを指定して、「インストール」ボタンを押下します。

※デフォルトでは「C:\Program Files (x86)\Microsoft Visual Studio\2017\Community」となっているため、特に問題がなければそのままで構いません。

※確認環境ではCドライブにSSDを利用しているため容量の関係でEドライブのHDDへ場所を変更しました。

※WPFプロジェクト作成を行うため「.NET デスクトップ開発」を選択しました。

インストール中は以下の画面が表示されますので終了するまで待ちます。

インストールが完了すると以下の画面が表示されます。

WPFプロジェクト作成

「ファイル」→「新規作成」→「プロジェクト」を選択します。

「WPFプロジェクト」を選択し以下の項目を入力してから「OK」ボタンを押下します。

  • 名前:プログラムの名称になります。
  • 場所:プロジェクトファイルの保存先になります。
  • フレームワーク:.NET frameworkのバージョンを指定します。(通常はデフォルトで問題ございませんが、理由により.NET frameworkのバージョンを変更できない端末で実行する場合に変更します。)
  • ソリューション(※)のディレクトリ作成:チェックしておくとソリューション名のフォルダーが作成されます。

※ソリューションは、複数のプロジェクト(メインプログラム、共通DLL、インストーラーなど)に分けて開発を行う場合にまとめて管理ができるので便利です。

以下の通りWPFプロジェクトが作成されました。

【開発環境構築】Mavenプロジェクトで実行Jarを作成【Java】

Java開発でMavenを使うことが多くなりなれてきたのでMavenプロジェクトを作成します。Mavenのいいところは「pom.xml」ファイルを編集することで外部jarファイルをダウンロードしてくれるところになります。



新規プロジェクト作成

「ファイル」→「新規」→「Mavenプロジェクト」を選択します。

「シンプルなプロジェクトの作成(S)(アーキタイプ選択のスキップ)」をチェックして「次へ」ボタンを押下します。

「グループId」、「アーティファクトId」を入力して「完了」ボタンを押下します。

グループId:一意に識別する名前(ルートパッケージなど)。(任意の文字列)

アーティファクトId:プロジェクトの名前。(任意の文字列)

アーティファクトIdに指定した名前のプロジェクトが追加されます。

パッケージの追加

ビルドを実行するプログラムを作成をするため、まずパッケージを作成します。

「src/main/java」を右クリックして「新規」→「パッケージ」を選択します。

「名前」を入力して「完了」ボタンを押下します。

パッケージが作成されます。

実行クラスの作成

起動時に実行するクラスを作成します。

折角なので「Swing」のUI画面を開始するようにします。

「src/main/java」に追加したパッケージで右クリックし「新規」→「その他」を選択します。

「WindowBuilder」→「Swingデザイナー」→「JFrame」を選択して、「次へ」ボタンを押下します。

「名前」を入力して「完了」ボタンを押下します。

クラスが作成されます。

ビルドの設定

「pom.xml」ファイルを開きます。

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.pg-nyoro</groupId>
  <artifactId>nyoro-tool</artifactId>
  <version>0.0.1-SNAPSHOT</version>
</project>

プロパティ定義(pom.xml内で利用する変数)を「<project>要素」に追加します。

  <!-- プロパティ定義 -->
  <properties>
  	<jdk.version>1.8</jdk.version>
  	<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

ビルド定義を「<project>要素」に追加します。

  <!-- ビルド設定 -->
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-shade-plugin</artifactId>
        <configuration>
          <transformers>
            <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
              <!-- 起動時に実行するクラスを指定する。 -->
              <mainClass>com.pg.nyoro.tool.MainFrame</mainClass>
            </transformer>
          </transformers>
        </configuration>
        <executions>
          <execution>
            <id>make-assembly</id>
            <phase>package</phase>
            <goals>
              <goal>shade</goal>
            </goals>
          </execution>
        </executions>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <configuration>
          <source>${jdk.version}</source>
          <target>${jdk.version}</target>
          <testSource>${jdk.version}</testSource>
          <testTarget>${jdk.version}</testTarget>
        </configuration>
      </plugin>
    </plugins>
    <resources>
      <resource>
        <directory>src/main/resources</directory>
      </resource>
    </resources>
  </build>

ビルドの実行

pom.xmlファイルを実行して実行可能なjarファイルを生成します。

「pom.xml」を見クリックして「実行」→「Maven ビルド…」を選択します。

「ゴール」に「package」を入力して「実行」ボタンを押下します。

コンソールにビルドの状態が表示され、最後に「BUILD SUCCESS」が表示されればビルド成功です。

プロジェクト上では以下のフォルダーに作成されています。

エクスプローラーでは以下のパスに格納されます。

「E:\pleiades-4.7.2-java\workspace\nyoro-tool\target\nyoro-tool-0.0.1-SNAPSHOT.jar」

※pleiades-4.7.2-java: Eclipseを展開したフォルダー名

※nyoro-tool: Mavenプロジェクト作成時に指定したアーティファクトId名

このパスはコンソールにも表示されておりますので確認できます。

実行可能Jarを起動

ビルドした実行可能Jarを起動します。

コマンドプロンプトを起動して以下のコマンドを実行します。

REM ## javaコマンドのパス指定
set path=%path%;E:\pleiades-4.7.2-java\java\8\bin\
REM ## 実行可能JARファイルの格納されているフォルダーへ移動
cd E:\pleiades-4.7.2-java\workspace\nyoro-tool\target
REM ## Jarファイルを実行
java -jar nyoro-tool-0.0.1-SNAPSHOT.jar

アプリケーションが実行されます。

なにも実装していないので空白の画面が表示されます。

ダブルクリックで実行する場合

Jarファイルを「Java」プログラムに関連付けすることでJarファイルをダブルクリックで実行することができます。ただ、Windows7の環境では動作したのですがWindows10の環境では動作しませんでした。

そのため、コマンド実行の方法を記載しております。

次回はspringを導入します。

【開発環境構築】swingでUIアプリの開発環境【java】

例えば職場でユーザの作業用に実行するコマンドを順番にならべた手順書を作成しているとき面倒だなと思ったことないでしょうか。
そんな時に、一連の作業を実行するツールを作ってツールの使い方を教えた方が気分的に楽しいかなと考えてツールづくりを始めようと思います。
Webアプリ開発環境でjavaを使うことが最近多く、Webアプリだとサーバー必須で環境関連でツール化するのが難しい・・・。
javaでUI作ろうと思うと「swing」を思いついて調べてみました。
今ではプラグインが充実していて開発するのが簡単になっていたので環境を構築する手順を書いてみます。



Eclipseダウンロード

まずは、Eclipseをインストールします。

職場でもよく使っている「Pleiades」という日本語化されたEclipseをダウンロードします。

http://mergedoc.osdn.jp/

今回は最新版の「Eclipse 4.7 Oxygen」をダウンロードします。

順番に押下するボタンを並べます。

 

容量は1.5GB程度なのでそれなりにダウンロードに時間がかかります。

Eclipseインストール

Cドライブなどドライブ直下にダウンロードしたファイルを移動して展開します。ファイルの展開には7zipを利用しました。

https://sevenzip.osdn.jp/

ダウンロードしたzipファイル「pleiades-4.7.2-java-win-64bit-jre_20171225.zip」を右クリックして「7-Zip」→「ここに展開」を実行します。

展開が完了すると以下のようなフォルダーが作成されます。

※複数のバージョンでEclipseを使う想定がある場合、展開後のフォルダー名を変更しておいた方がよいです。他のバージョンのEclipseを同じ手順で展開すると上書きされてEclipseが壊れてしまいます。

「pleiades」→「pleiades-4.7.2-java」など

インストールはこれで終わりになります。

Eclipse起動

Eドライブにインストールしました。

プログラムファイル「E:\pleiades-4.7.2-java\eclipse\eclipse.exe」を実行します。

実行すると以下のようなスプラッシュ画面が表示されますのでしばらく待ちます。

しばらくすると以下のようにワークスペースの選択を要求してきますのでそのまま「起動」ボタンを押下します。

スプラッシュ画面が表示された後に起動した画面が以下の通りでございます。

プラグインインストール

「ヘルプ」→「新規ソフトウェアのインストール…」を選択します。

作業対象に「Oxygen – http://download.eclipse.org/releases/oxygen」を選択します。

「swing」でフィルターを指定します。

「一般用ツール」→「Swingデザイナー」を選択して「次へ」ボタンを押下します。

「次へ」ボタンを押下してインストールを実行します。

「使用条件の条項に同意します。」をチェックして「完了」ボタンを押下します。

バックグラウンドでインストールが行われ、しばらくするとダイアログが表示されるので「今すぐ再起動」ボタンを押下します。

Eclipseが再起動されます。

インストール後の確認

Eclipseが起動したら「ファイル」→「新規」→「その他」を選択します。

「Swingデザイナー」が追加されていればインストール成功です。

次回はMavenプロジェクトを作成します。

【開発環境構築】swingでUIアプリの開発環境【java】

【C#】処理を共通化するという考え方

暗号化・複合化処理を文字列、ファイルを別々にコードを書いているため共通化します。

コードの共通部分を抜き出して共通化しておくことで新規に追加実装する部分は拡張部のみにすることもできます。

今回、共通化するコードは以下のリンク先にある記事で利用したコードの共通部分を抜き出して共通化します。




【C#】ファイルの暗号化・複合化を行う。【AES暗号化】

Encode → EncodeString

Decode → DecodeString

 

【C#】文字列の暗号化・複合化を行う。【AES暗号化】

Encode → EncodeFile

Decode → DecodeFile

 

コードを共通化することで、拡張する関数の実装が簡素化します。


using System;
using System.IO;
using System.IO.Compression;
using System.Security.Cryptography;
using System.Text;

namespace TestCode.Utility
{
    public class AesUtil
    {
        /// <summary>
        /// 共有キー
        /// </summary>
        private const string AES_KEY = "-SENJU MURAMASA-";

        /// <summary>
        /// バッファサイズ
        /// </summary>
        private const int BUFFER_SIZE = 1024 * 4;

        /// <summary>
        /// 共有キービットサイズ
        /// </summary>
        private const int KEY_SIZE = 128;

        /// <summary>
        /// 暗号操作のビットサイズ
        /// </summary>
        private const int BLOCK_SIZE = 128;

        /// <summary>
        /// 暗号化(文字列) - 入力・出力メモリストリームを共通関数へ渡す
        /// </summary>
        /// <param name="value">暗号化する文字列</param>
        /// <returns>暗号化した文字列</returns>
        static public string EncodeString(string value)
        {
            // 入力ストリーム
            using (MemoryStream inMs = new MemoryStream(Encoding.UTF8.GetBytes(value)))
            {
                // 出力ストリーム
                using (MemoryStream outMs = new MemoryStream())
                {
                    // 共通関数呼び出し
                    AesUtil.Encode(inMs, outMs);

                    // BASE64エンコードして返す
                    return Convert.ToBase64String(outMs.ToArray());
                }
            }
        }

        /// <summary>
        /// 複合化(文字列) - 入力・出力メモリストリームを共通関数へ渡す
        /// </summary>
        /// <param name="value">暗号化されている文字列</param>
        /// <returns>複合化された文字列</returns>
        static public string DecodeString(string value)
        {
            // 暗号化文字列ストリーム生成(BASE64でコード)
            using (MemoryStream inMs = new MemoryStream(Convert.FromBase64String(value), false))
            {
                // 出力ストリーム
                using (MemoryStream outMs = new MemoryStream())
                {
                    // 共通関数呼び出し
                    AesUtil.Decode(inMs, outMs);

                    // バイナリデータを文字列変換して返す
                    return Encoding.UTF8.GetString(outMs.ToArray());
                }
            }
        }

        /// <summary>
        /// 暗号化(ファイル) - 入力・出力ファイルストリームを共通関数へ渡す
        /// </summary>
        /// <param name="src">入力ファイルパス</param>
        /// <param name="dst">出力ファイルパス</param>
        static public void EncodeFile(string src, string dst)
        {
            // 入力ファイルストリーム
            using (FileStream inFs = new FileStream(src, FileMode.Open, FileAccess.Read))
            {
                // 出力ファイルストリーム
                using (FileStream outFs = new FileStream(dst, FileMode.Create, FileAccess.Write))
                {
                    // 共通関数呼び出し
                    AesUtil.Encode(inFs, outFs);
                }
            }
        }

        /// <summary>
        /// 複合化(ファイル) - 入力・出力ファイルストリームを共通関数へ渡す
        /// </summary>
        /// <param name="src">入力ファイルパス</param>
        /// <param name="dst">出力ファイルパス</param>
        static public void DecodeFile(string src, string dst)
        {
            // 入力ファイルストリーム
            using (FileStream inFs = new FileStream(src, FileMode.Open, FileAccess.Read))
            {
                // 出力ファイルストリーム
                using (FileStream outFs = new FileStream(dst, FileMode.Create, FileAccess.Write))
                {
                    // 共通関数呼び出し
                    AesUtil.Decode(inFs, outFs);
                }
            }
        }

        /// <summary>
        /// 暗号化(共通関数)- 暗号化に共通するコードを抜き出した関数
        /// </summary>
        /// <param name="src">入力ストリーム</param>
        /// <param name="dst">出力ストリーム</param>
        static private void Encode(Stream src, Stream dst)
        {
            // 高度暗号化標準 (AES) 
            using (AesManaged aes = new AesManaged())
            {
                // AESインスタンスのパラメータ設定
                aes.KeySize = KEY_SIZE;
                aes.BlockSize = BLOCK_SIZE;
                aes.Mode = CipherMode.CBC;
                aes.Key = Encoding.UTF8.GetBytes(AES_KEY);

                // 初期化ベクター(IV)の生成
                aes.GenerateIV();

                // 暗号化オブジェクト生成
                ICryptoTransform ct = aes.CreateEncryptor(aes.Key, aes.IV);

                // 初期化ベクター(IV)書き込み
                dst.Write(aes.IV, 0, aes.IV.Length);

                // 暗号変換のストリーム(暗号化)
                using (CryptoStream cs = new CryptoStream(dst, ct, CryptoStreamMode.Write))
                {
                    // Deflateアルゴリズムを使用したストリーム(圧縮)
                    using (DeflateStream ds = new DeflateStream(cs, CompressionMode.Compress))
                    {
                        byte[] buf = new byte[BUFFER_SIZE];
                        for (int size = src.Read(buf, 0, buf.Length); size > 0; size = src.Read(buf, 0, buf.Length))
                        {
                            // 出力ファイルへ書き込み(圧縮→暗号化→書き込み)
                            ds.Write(buf, 0, size);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 複合化(共通関数)- 複合化に共通するコードを抜き出した関数
        /// </summary>
        /// <param name="src">入力ストリーム</param>
        /// <param name="dst">出力ストリーム</param>
        static public void Decode(Stream src, Stream dst)
        {
            // 高度暗号化標準(AES)
            using (AesManaged aes = new AesManaged())
            {
                // AESインスタンスのパラメータ設定
                aes.KeySize = KEY_SIZE;
                aes.BlockSize = BLOCK_SIZE;
                aes.Mode = CipherMode.CBC;
                aes.Key = Encoding.UTF8.GetBytes(AES_KEY);

                // 初期化ベクター(IV)読込
                byte[] iv = new byte[aes.IV.Length];
                src.Read(iv, 0, iv.Length);
                aes.IV = iv;

                // 複合化オブジェクト生成
                ICryptoTransform ct = aes.CreateDecryptor(aes.Key, aes.IV);

                // 暗号変換のストリーム(複合化)
                using (CryptoStream cs = new CryptoStream(src, ct, CryptoStreamMode.Read))
                {
                    // Deflateアルゴリズムを使用したストリーム(圧縮解除)
                    using (DeflateStream ds = new DeflateStream(cs, CompressionMode.Decompress))
                    {
                        // 複合化した結果を書き込む
                        byte[] buf = new byte[BUFFER_SIZE];
                        for (int size = ds.Read(buf, 0, buf.Length); size > 0; size = ds.Read(buf, 0, buf.Length))
                        {
                            dst.Write(buf, 0, size);
                        }
                    }
                }
            }
        }
    }
}

入力・出力ストリームを引数として共通化することで共通関数を実装しております。

【C#】ファイルの暗号化・複合化を行う。【AES暗号化】

文字列の暗号化・複合化を行うコードの亜種としてファイルを扱う場合を記載します。

Visual Studioの環境構築




using System;
using System.IO;
using System.IO.Compression;
using System.Security.Cryptography;
using System.Text;

namespace TestCode.Utility
{
    public class AesUtil
    {
        /// <summary>
        /// 共有キー
        /// </summary>
        private const string AES_KEY = "-SENJU MURAMASA-";

        /// <summary>
        /// バッファサイズ
        /// </summary>
        private const int BUFFER_SIZE = 1024 * 4;

        /// <summary>
        /// 共有キービットサイズ
        /// </summary>
        private const int KEY_SIZE = 128;

        /// <summary>
        /// 暗号操作のビットサイズ
        /// </summary>
        private const int BLOCK_SIZE = 128;

        /// <summary>
        /// 暗号化
        /// </summary>
        /// <param name="src">入力ファイルパス</param>
        /// <param name="dst">出力ファイルパス</param>
        static public void Encode(string src, string dst)
        {
            // 高度暗号化標準 (AES) 
            using (AesManaged aes = new AesManaged())
            {
                // AESインスタンスのパラメータ設定
                aes.KeySize = KEY_SIZE;
                aes.BlockSize = BLOCK_SIZE;
                aes.Mode = CipherMode.CBC;
                aes.Key = Encoding.UTF8.GetBytes(AES_KEY);

                // 初期化ベクター(IV)の生成
                aes.GenerateIV();

                // 暗号化オブジェクト生成
                ICryptoTransform ct = aes.CreateEncryptor(aes.Key, aes.IV);

                // 出力ファイルストリーム
                using (FileStream outFs = new FileStream(dst, FileMode.Create, FileAccess.Write))
                {
                    // 初期化ベクター(IV)書き込み
                    outFs.Write(aes.IV, 0, aes.IV.Length);

                    // 暗号変換のストリーム(暗号化)
                    using (CryptoStream cs = new CryptoStream(outFs, ct, CryptoStreamMode.Write))
                    {
                        // Deflateアルゴリズムを使用したストリーム(圧縮)
                        using (DeflateStream ds = new DeflateStream(cs, CompressionMode.Compress))
                        {
                            // 入力ファイルストリーム
                            using (FileStream inFs = new FileStream(src, FileMode.Open, FileAccess.Read))
                            {
                                byte[] buf = new byte[BUFFER_SIZE];
                                for (int size = inFs.Read(buf, 0, buf.Length); size > 0; size = inFs.Read(buf, 0, buf.Length))
                                {
                                    // 出力ファイルへ書き込み(圧縮→暗号化→書き込み)
                                    ds.Write(buf, 0, size);
                                }
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 複合化
        /// </summary>
        /// <param name="src">入力ファイルパス</param>
        /// <param name="dst">出力ファイルパス</param>
        static public void Decode (string src, string dst)
        {
            // 高度暗号化標準(AES)
            using (AesManaged aes = new AesManaged())
            {
                // AESインスタンスのパラメータ設定
                aes.KeySize = KEY_SIZE;
                aes.BlockSize = BLOCK_SIZE;
                aes.Mode = CipherMode.CBC;
                aes.Key = Encoding.UTF8.GetBytes(AES_KEY);

                // 入力ファイルストリーム
                using (FileStream inFs = new FileStream(src, FileMode.Open, FileAccess.Read))
                {
                    // 初期化ベクター(IV)読込
                    byte[] iv = new byte[aes.IV.Length];
                    inFs.Read(iv, 0, iv.Length);
                    aes.IV = iv;

                    // 複合化オブジェクト生成
                    ICryptoTransform ct = aes.CreateDecryptor(aes.Key, aes.IV);

                    // 暗号変換のストリーム(複合化)
                    using (CryptoStream cs = new CryptoStream(inFs, ct, CryptoStreamMode.Read))
                    {
                        // Deflateアルゴリズムを使用したストリーム(圧縮解除)
                        using (DeflateStream ds = new DeflateStream(cs, CompressionMode.Decompress))
                        {
                            // 出力ファイルストリーム
                            using (FileStream outFs = new FileStream(dst, FileMode.Create, FileAccess.Write))
                            {
                                // 複合化した結果を書き込む
                                byte[] buf = new byte[BUFFER_SIZE];
                                for (int size = ds.Read(buf, 0, buf.Length); size > 0; size = ds.Read(buf, 0, buf.Length))
                                {
                                    outFs.Write(buf, 0, size);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

【C#】文字列の暗号化・複合化を行う。【AES暗号化】

サーバーに配置するテキストファイル内の文字列を暗号化する要件があり、暗号化及び、複合化を行う関数をまとめてみました。

Visual Studioの環境構築



そのまま張り付けるコード


using System;
using System.IO;
using System.IO.Compression;
using System.Security.Cryptography;
using System.Text;

namespace TestCode.Utility
{
    public class AesUtil
    {
        /// <summary>
        /// 共有キー
        /// </summary>
        private const string AES_KEY = "-SENJU MURAMASA-";

        /// <summary>
        /// バッファサイズ
        /// </summary>
        private const int BUFFER_SIZE = 1024 * 4;

        /// <summary>
        /// 共有キービットサイズ
        /// </summary>
        private const int KEY_SIZE = 128;

        /// <summary>
        /// 暗号操作のビットサイズ
        /// </summary>
        private const int BLOCK_SIZE = 128;

        /// <summary>
        /// 暗号化
        /// </summary>
        /// <param name="value">暗号化する文字列</param>
        /// <returns>暗号化した文字列</returns>
        static public string Encode(string value)
        {
            // 高度暗号化標準 (AES) 
            using (AesManaged aes = new AesManaged())
            {
                // AESインスタンスのパラメータ設定
                aes.KeySize = KEY_SIZE;
                aes.BlockSize = BLOCK_SIZE;
                aes.Mode = CipherMode.CBC;
                aes.Key = Encoding.UTF8.GetBytes(AES_KEY);

                // 初期化ベクター(IV)の生成
                aes.GenerateIV();

                // 暗号化オブジェクト生成
                ICryptoTransform ct = aes.CreateEncryptor(aes.Key, aes.IV);

                // 出力ストリーム
                using (MemoryStream outMs = new MemoryStream())
                {
                    // 初期化ベクター(IV)書き込み
                    outMs.Write(aes.IV, 0, aes.IV.Length);

                    // 暗号変換のストリーム(暗号化)
                    using (CryptoStream cs = new CryptoStream(outMs, ct, CryptoStreamMode.Write))
                    {
                        // Deflateアルゴリズムを使用したストリーム(圧縮)
                        using (DeflateStream ds = new DeflateStream(cs, CompressionMode.Compress))
                        {
                            // 文字列を書き込む
                            byte[] buf = Encoding.UTF8.GetBytes(value);
                            ds.Write(buf, 0, buf.Length);
                        }
                    }
                    // BASE64エンコードして返す
                    return Convert.ToBase64String(outMs.ToArray());
                }
            }
        }

        /// <summary>
        /// 複合化
        /// </summary>
        /// <param name="value">暗号化されている文字列</param>
        /// <returns>複合化された文字列</returns>
        static public string Decode(string value)
        {
            // 高度暗号化標準(AES)
            using (AesManaged aes = new AesManaged())
            {
                // AESインスタンスのパラメータ設定
                aes.KeySize = KEY_SIZE;
                aes.BlockSize = BLOCK_SIZE;
                aes.Mode = CipherMode.CBC;
                aes.Key = Encoding.UTF8.GetBytes(AES_KEY);

                // 暗号化文字列ストリーム生成(BASE64でコード)
                using (MemoryStream inMs = new MemoryStream(Convert.FromBase64String(value), false))
                {
                    // 初期化ベクター(IV)読込
                    byte[] iv = new byte[aes.IV.Length];
                    inMs.Read(iv, 0, iv.Length);
                    aes.IV = iv;

                    // 複合化オブジェクト生成
                    ICryptoTransform ct = aes.CreateDecryptor(aes.Key, aes.IV);

                    // 暗号変換のストリーム(複合化)
                    using (CryptoStream cs = new CryptoStream(inMs, ct, CryptoStreamMode.Read))
                    {
                        // Deflateアルゴリズムを使用したストリーム(圧縮解除)
                        using (DeflateStream ds = new DeflateStream(cs, CompressionMode.Decompress))
                        {
                            // 出力ストリーム
                            using (MemoryStream outMs = new MemoryStream())
                            {
                                // 複合化した結果を書き込む
                                byte[] buf = new byte[BUFFER_SIZE];
                                for (int size = ds.Read(buf, 0, buf.Length); size > 0; size = ds.Read(buf, 0, buf.Length))
                                {
                                    outMs.Write(buf, 0, size);
                                }

                                // バイナリデータを文字列変換して返す
                                return Encoding.UTF8.GetString(outMs.ToArray());
                            }
                        }
                    }
                }
            }
        }
    }
}