C# – ページ 2 – サイゼントの技術ブログ

2020年10月16日

無名クラスとは

javaやC#では、インスタンス変数をnewする際に、後ろに中かっこを記述し定義を行うことができます。
ここで定義されるものは「無名クラス（匿名クラス）」と呼ばれ、クラス名を新たに定義することなく、インスタンス変数のクラス・インターフェースを継承・実装したクラスを定義することができます。
（ちなみに、「ラムダ式」と呼ばれる文法は「無名クラス」を応用したものになります）

以下、javaの例です。

【サンプルコード】

・AnonymousClass.java

public class AnonymousClass {
    private String STR = "Hello Class!";
    public String getSTR() {
        return STR;
    }
    public void print() {
        System.out.println(getSTR());
    }
}

public class AnonymousClass {

private String STR = "Hello Class!";

public String getSTR() {

return STR;

}

public void print() {

System.out.println(getSTR());

}

・AnonymousInterface.java

public interface AnonymousInterface {
    public void print();
}

public interface AnonymousInterface {

public void print();

}

・AnonymousMain.java

public class AnonymousMain {
    public static void main(String［］ args) {

        // 匿名クラス作成（クラスの継承）
        AnonymousClass ac = new AnonymousClass(){
            public void print() {
                System.out.println("Anonymous:" + getSTR());
            }
        };
        ac.print();

        // 匿名クラス作成（インターフェースの実装）
        AnonymousInterface ai = new AnonymousInterface() {
            public void print() {
                System.out.println("Anonymous:Hello Interface!");
            }
        };
        ai.print();
    }
}

public class AnonymousMain {

public static void main(String［］ args) {

// 匿名クラス作成（クラスの継承）

AnonymousClass ac = new AnonymousClass(){

public void print() {

System.out.println("Anonymous:" + getSTR());

}

};

ac.print();

// 匿名クラス作成（インターフェースの実装）

AnonymousInterface ai = new AnonymousInterface() {

public void print() {

System.out.println("Anonymous:Hello Interface!");

}

};

ai.print();

}

【実行結果】

Anonymous:Hello Class!
Anonymous:Hello Interface!

1 2	Anonymous:Hello Class! Anonymous:Hello Interface!

いかがでしたでしょうか。

無名クラスは、使い捨てのクラスを作りたい時に便利です。
また、前述のラムダ式等を理解する上でも、無名クラスを理解する必要があります。

javaの入門書には出てくることが少ない文法だと思いますが、javaに慣れたらこの文法も早い内に理解することをお勧めします。

2020年8月21日2020年8月22日

型推論とは、メソッド内のローカル変数を初期値付きで（右辺がある状態で）宣言する際に、通常の型宣言の代わりに”var”という仮の型を使用できるという文法です。
“var”を用いた際は、コンパイル時に自動で型を判断し、その型への置き換えが行われます。

C#では3.0(2007/11)から導入されており、現在ではお馴染みの文法と言えるでしょう。
Javaでは長らく導入されていませんでしたが、10(2018/03)でついに導入されました。
今後はJavaの案件でも目にすることが増えると思います。

型推論を用いることで、冗長な型宣言をすっきりさせることができます。
C#の例で言うと、下記のコードで、定義時に”List”と型を指定している箇所は、”var”に書き変えることができます。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloWorld
{
    class Program
    {
        static void Main(string［］ args)
        {
            //List＜string＞ list = new List＜string＞();
            var list = new List＜string＞();
            list.Add("Hello ");
            list.Add("World");
            list.Add("!");
            foreach(string str in list)
            {
                Console.Write(str);
            }
            Console.WriteLine("");
            Console.ReadKey(true);
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace HelloWorld

{

class Program

{

static void Main(string［］ args)

{

//List＜string＞ list = new List＜string＞();

var list = new List＜string＞();

list.Add("Hello ");

list.Add("World");

list.Add("!");

foreach(string str in list)

{

Console.Write(str);

}

Console.WriteLine("");

Console.ReadKey(true);

}

また、ソース修正で型を変えるような場合にも、”var”と記述した部分は変更する必要がなくなるので、ソース修正が楽になるというメリットもあります。

型はコンパイル時に決まるため、実行時に動的に型が変わることはありません。
例えば、下記のようなコードはコンパイルエラーになります。
（(22,20): error CS0029: 型 ‘int’ を型 ‘System.Collections.Generic.List’ に暗黙的に変換できません。）
誤って意図しない型を代入しようとした場合はコンパイル時にエラーとして検知できるので、その意味では安心して使えます。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HelloWorld
{
    class Program
    {
        static void Main(string［］ args)
        {
            var list = new List＜string＞();
            list.Add("Hello ");
            list.Add("World");
            list.Add("!");
            foreach(string str in list)
            {
                Console.Write(str);
            }
            Console.WriteLine("");
            list = 1 + 2; // 途中でintのような使い方をするとコンパイルエラー
            Console.WriteLine(list.ToString());
            Console.ReadKey(true);
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace HelloWorld

{

class Program

{

static void Main(string［］ args)

{

var list = new List＜string＞();

list.Add("Hello ");

list.Add("World");

list.Add("!");

foreach(string str in list)

{

Console.Write(str);

}

Console.WriteLine("");

list = 1 + 2; // 途中でintのような使い方をするとコンパイルエラー

Console.WriteLine(list.ToString());

Console.ReadKey(true);

}

ちなみに、「型推論」と似た概念として「動的型付け」というものがあるのですが、こちらは途中で異なる型を代入すると変数の型そのものが変わり処理が続行されます。
例えば、JavaScriptでは動的型付けが採用されており、予約語も”var”を用いるため、「型推論」と混同されがちです。
「動的型付け」の方は誤って意図しない型を代入しても実行するまで気付くことができず、実行時に出るエラーが分かりにくいものだったり、そもそもエラーが出ないこともあるので、注意が必要です。

以上のように便利な型推論ですが、可読性を落とすデメリットもあります。
具体的に言うと、変数宣言時の型が一目瞭然ではない場合に用いると可読性を落とします。

例えば、下記のコードで変数宣言時の型を知るためには、”MyFunc”の仕様を知っている必要があります。
“MyFunc”のような独自の関数でなくても、チーム内での知名度が低い関数を用いる場合は注意が必要です。

var hoge = MyFunc();

1	var hoge = MyFunc();

また、”int”や”string”のような基本的な型に対して用いるのも、元々型宣言が冗長ではないという意味で型推論を使用するメリットが少ないので、他の開発者に違和感を抱かせてしまう可能性があります。

いかがでしたでしょうか？

「型推論」は便利ながらも、「動的型付け」のように実行時エラーを引き起こす原因を作ることはないので、安心して使える文法だと思います。
その使いやすさからJavaでも今後目にする機会が増えると思うので、このような文法があるということは頭に入れておいて損はないと思います。

Javaのバージョンは今でも上がり続けているので、新しい便利な文法があればこれからも紹介したいと思います！

2020年8月7日

C#：await・asyncの簡単なサンプルコード

C#のawait・asyncは非同期処理のために用意された文法なのですが、Webで調べてみても難しく書かれていることが多く、そもそも何のための処理なのか理解するのが難しい感があります。
await・asyncを用いて関数を呼び出しても、その関数の処理が終わるまで待つという動きをするので、同期処理と何が違うのかいまいちわかりにくいというのもあると思います。
以上のような背景があるので、簡単なサンプルコードを書いてみることとしました。

await・asyncは、GUIアプリのために用意された文法と考えて良いです。
await・asyncを用いない場合、処理中はGUI操作ができなくなるのですが、await・asyncを用いて呼び出した関数を処理している間はGUI操作が可能になります。
GUI操作と並行で処理ができる、という意味で、await・asyncは非同期処理であると言えます。

以下、Windows Formのサンプルコードです。
３秒後にボタン押下時のシステム時刻をラベルに表示するというサンプルコードであり、await・asyncを用いたボタンとそうではないボタンを用意して挙動の違いを確認します。

【サンプルコード】

・From1.cs（デザイン）

・Form1.cs（ビジネスロジック）

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace AsyncAwaitTest
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        // Asyncボタン
        private async void button1_Click(object sender, EventArgs e)
        {
            String date = await AsyncProc();
            label1.Text = date;
        }

        private async Task＜String＞ AsyncProc()
        {
            DateTime dt = DateTime.Now;
            await Task.Delay(3000);
            return dt.ToString();
        }

        // NoAsyncボタン
        private void button2_Click(object sender, EventArgs e)
        {
            String date = NoAsyncProc();
            label2.Text = date;
        }

        private String NoAsyncProc()
        {
            DateTime dt = DateTime.Now;
            Thread.Sleep(3000);
            return dt.ToString();
        }
    }
}

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Linq;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using System.Windows.Forms;

namespace AsyncAwaitTest

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

}

// Asyncボタン

private async void button1_Click(object sender, EventArgs e)

{

String date = await AsyncProc();

label1.Text = date;

}

private async Task＜String＞ AsyncProc()

{

DateTime dt = DateTime.Now;

await Task.Delay(3000);

return dt.ToString();

}

// NoAsyncボタン

private void button2_Click(object sender, EventArgs e)

{

String date = NoAsyncProc();

label2.Text = date;

}

private String NoAsyncProc()

{

DateTime dt = DateTime.Now;

Thread.Sleep(3000);

return dt.ToString();

}

【実行結果】

・Asyncボタンを押してから１秒以内にNoAsyncボタンを押下

→Asyncボタンの処理中もNoAsyncボタンを押下可能であるため、２つのボタンに対応するラベルの表示上、時刻の差異は１秒以内です。

・NoAsyncボタンを押してから１秒以内にAsyncボタンを押下

→NoAsyncボタンの処理中はAsyncボタンを押下不可能であるため、２つのボタンに対応するラベルの表示上、時刻の差異は３秒以上となります。

いかがでしたでしょうか。

説明を読んでも関数の挙動や目的がわからなかったのですが、自分で簡単なプログラムを作って動かしてみて理解できました。
今回の記事はC#でGUIのプログラムを作っている人以外には参考にならない記事だったかもしれませんが、簡単なプログラムを作って理解を深める例を示すことはできたのではないかと思っています。

2020年7月24日

C#：セマフォを用いた排他制御

排他制御の仕組みとして先日Mutexを取り上げました。
今回は、同じく排他制御で使われるセマフォについて取り上げます。

セマフォがMutexと異なる点は、複数のプロセス・スレッドが資源を取得することができることです。
セマフォのコンストラクタで初期で解放する資源数や、解放できる資源の最大数を指定します。
WaitOne関数で資源取得待ちを行い、Release関数で資源解放を行います。Release関数の引数で資源解放数を指定することもできます。
（ただし、最大数を超える資源を開放するとSemaphoreFullExceptionとなるので注意が必要です）

セマフォは、同時に動くスレッド数を制限したいような重い処理がある時によく使われます。

以下は、セマフォを用いて同時に動くスレッド数を制限するサンプルです。

【サンプルコード】

・Controller.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
namespace Controller
{
    internal class Controller
    {
        public static void Main(string［］ args)
        {
            using(Semaphore sem = new Semaphore(0, 2, "semaphore"))
            {
                Console.WriteLine(DateTime.Now + 
                    "：セマフォを作りました。" + 
                    "初期で解放０個、最大で２つまで解放します。");
                Thread.Sleep(2000);
                sem.Release(2);
                Console.WriteLine(DateTime.Now + 
                    "：準備ができたので、セマフォを２つ解放しました。");
                Thread.Sleep(10000);
            }
            Console.ReadLine();
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Threading;

namespace Controller

{

internal class Controller

{

public static void Main(string［］ args)

{

using(Semaphore sem = new Semaphore(0, 2, "semaphore"))

{

Console.WriteLine(DateTime.Now +

"：セマフォを作りました。" +

"初期で解放０個、最大で２つまで解放します。");

Thread.Sleep(2000);

sem.Release(2);

Console.WriteLine(DateTime.Now +

"：準備ができたので、セマフォを２つ解放しました。");

Thread.Sleep(10000);

}

Console.ReadLine();

}

・Processor.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
namespace Processor
{
    internal class Processor
    {
        public static void Main(string［］ args)
        {
            const int N = 3;
            Parallel.For(0, N, id =＞ // id0～2のスレッドを生成
            {
                Semaphore sem;
                if (Semaphore.TryOpenExisting("semaphore", out sem))
                {
                    Console.WriteLine("ID" + id + ":" + DateTime.Now + 
                        "：セマフォ解放待ち。");
                    sem.WaitOne();
                    Console.WriteLine("ID" + id + ":" + DateTime.Now + 
                        "：セマフォ取得しました。処理開始します。");
                    Thread.Sleep(2000);
                    Console.WriteLine("ID" + id + ":" + DateTime.Now + 
                        "：処理終了しました。");
                    sem.Release();
                    Console.WriteLine("ID" + id + ":" + DateTime.Now + 
                        "：処理終了したので、セマフォを１つ解放しました。");
                }
                else
                {
                    Console.WriteLine("ID" + id + ":" + DateTime.Now + 
                        "：セマフォが見つかりません。");
                }
            });
            Console.ReadLine();
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.Threading;

namespace Processor

{

internal class Processor

{

public static void Main(string［］ args)

{

const int N = 3;

Parallel.For(0, N, id =＞ // id0～2のスレッドを生成

{

Semaphore sem;

if (Semaphore.TryOpenExisting("semaphore", out sem))

{

Console.WriteLine("ID" + id + ":" + DateTime.Now +

"：セマフォ解放待ち。");

sem.WaitOne();

Console.WriteLine("ID" + id + ":" + DateTime.Now +

"：セマフォ取得しました。処理開始します。");

Thread.Sleep(2000);

Console.WriteLine("ID" + id + ":" + DateTime.Now +

"：処理終了しました。");

sem.Release();

Console.WriteLine("ID" + id + ":" + DateTime.Now +

"：処理終了したので、セマフォを１つ解放しました。");

}

else

{

Console.WriteLine("ID" + id + ":" + DateTime.Now +

"：セマフォが見つかりません。");

}

});

Console.ReadLine();

}

【実行用バッチ】

・test.bat

@echo off
echo 最大で２つのスレッドしか動かないようにするサンプルです。
echo 同時に動くスレッド数を制限したい重い処理がある時に使えます。
C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe Controller.cs
C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe Processor.cs
start Controller.exe
timeout 1
start Processor.exe
pause
exit

@echo off

echo 最大で２つのスレッドしか動かないようにするサンプルです。

echo 同時に動くスレッド数を制限したい重い処理がある時に使えます。

C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe Controller.cs

C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe Processor.cs

start Controller.exe

timeout 1

start Processor.exe

pause

exit

【実行結果】

・test.bat

最大で２つのスレッドしか動かないようにするサンプルです。
同時に動くスレッド数を制限したい重い処理がある時に使えます。
Microsoft (R) Visual C# Compiler version 4.7.3062.0
for C# 5
Copyright (C) Microsoft Corporation. All rights reserved.

This compiler is provided as part of the Microsoft (R) .NET Framework, but only supports language versions up to C# 5, w
hich is no longer the latest version. For compilers that support newer versions of the C# programming language, see http
://go.microsoft.com/fwlink/?LinkID=533240

Microsoft (R) Visual C# Compiler version 4.7.3062.0
for C# 5
Copyright (C) Microsoft Corporation. All rights reserved.

This compiler is provided as part of the Microsoft (R) .NET Framework, but only supports language versions up to C# 5, w
hich is no longer the latest version. For compilers that support newer versions of the C# programming language, see http
://go.microsoft.com/fwlink/?LinkID=533240


0 秒待っています。続行するには何かキーを押してください ...
続行するには何かキーを押してください . . .

最大で２つのスレッドしか動かないようにするサンプルです。

同時に動くスレッド数を制限したい重い処理がある時に使えます。

Microsoft (R) Visual C# Compiler version 4.7.3062.0

for C# 5

This compiler is provided as part of the Microsoft (R) .NET Framework, but only supports language versions up to C# 5, w

hich is no longer the latest version. For compilers that support newer versions of the C# programming language, see http

://go.microsoft.com/fwlink/?LinkID=533240

Microsoft (R) Visual C# Compiler version 4.7.3062.0

for C# 5

This compiler is provided as part of the Microsoft (R) .NET Framework, but only supports language versions up to C# 5, w

hich is no longer the latest version. For compilers that support newer versions of the C# programming language, see http

://go.microsoft.com/fwlink/?LinkID=533240

0 秒待っています。続行するには何かキーを押してください ...

続行するには何かキーを押してください . . .

・Controller.exe

2020/05/09 13:48:45：セマフォを作りました。初期で解放０個、最大で２つまで解放します。
2020/05/09 13:48:47：準備ができたので、セマフォを２つ解放しました。

1 2	2020/05/09 13:48:45：セマフォを作りました。初期で解放０個、最大で２つまで解放します。 2020/05/09 13:48:47：準備ができたので、セマフォを２つ解放しました。

・Processor.exe

ID0:2020/05/09 13:48:46：セマフォ解放待ち。
ID2:2020/05/09 13:48:46：セマフォ解放待ち。
ID1:2020/05/09 13:48:46：セマフォ解放待ち。
ID0:2020/05/09 13:48:47：セマフォ取得しました。処理開始します。
ID2:2020/05/09 13:48:47：セマフォ取得しました。処理開始します。
ID2:2020/05/09 13:48:49：処理終了しました。
ID0:2020/05/09 13:48:49：処理終了しました。
ID0:2020/05/09 13:48:49：処理終了したので、セマフォを１つ解放しました。
ID2:2020/05/09 13:48:49：処理終了したので、セマフォを１つ解放しました。
ID1:2020/05/09 13:48:49：セマフォ取得しました。処理開始します。
ID1:2020/05/09 13:48:51：処理終了しました。
ID1:2020/05/09 13:48:51：処理終了したので、セマフォを１つ解放しました。

ID0:2020/05/09 13:48:46：セマフォ解放待ち。

ID2:2020/05/09 13:48:46：セマフォ解放待ち。

ID1:2020/05/09 13:48:46：セマフォ解放待ち。

ID0:2020/05/09 13:48:47：セマフォ取得しました。処理開始します。

ID2:2020/05/09 13:48:47：セマフォ取得しました。処理開始します。

ID2:2020/05/09 13:48:49：処理終了しました。

ID0:2020/05/09 13:48:49：処理終了しました。

ID0:2020/05/09 13:48:49：処理終了したので、セマフォを１つ解放しました。

ID2:2020/05/09 13:48:49：処理終了したので、セマフォを１つ解放しました。

ID1:2020/05/09 13:48:49：セマフォ取得しました。処理開始します。

ID1:2020/05/09 13:48:51：処理終了しました。

ID1:2020/05/09 13:48:51：処理終了したので、セマフォを１つ解放しました。

いかがでしたでしょうか？

排他制御の仕組みとしてMutexを説明したので、ついでに代表的な方法の一つであるセマフォについても説明しました。
Mutexよりも使用頻度は少ないと思いますが、同時に動くスレッド数を制限するための書き方があるというのは覚えておいて損はないと思います。

2020年7月11日

C#：共有メモリで可変長データを繰り返し送受信する

共有メモリは、同一メモリ上で実行されるプロセス間でデータをやりとりする場合に使用する仕組みです。
通常、プロセスで確保しているメモリは他のプロセスから参照することができないのですが、プロセス間で予め共有メモリとして使用するメモリのアドレスを共有することで、そのメモリは他のプロセスから参照可能となります。
ファイル等を介したやりとりよりも高速なため、高速化が求められる時に使用することが多いです。

目的の一つが高速化のため、データが作成され次第次々と共有する、という使い方になることが多いと思います。
今回は、そのような使い方を想定して、可変長データを繰り返し送受信するサンプルプログラムを作成しました。
書き込んだデータのサイズを伝えること、共有メモリの読み取り位置をずらしていくことがポイントとなります。

なお、今回は省略していますが、本来であれば書き込み中の読み取りを防ぐため、Mutex等の排他制御の仕組みを併用するべきです。
（参考までに、Mutexについては前回の記事で取り上げています）

【サンプルコード】

・Sender.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO.MemoryMappedFiles;

namespace Sender
{
    class Sender
    {
        // 本当はMutex等で排他制御するべき
        static void Main(string［］ args)
        {
            // 共有メモリの作成("HelloWorld"という名前で1024バイトで定義)
            MemoryMappedFile mmf = 
                MemoryMappedFile.CreateNew("HelloWorld", 1024);
            
            // 書き込みオブジェクトの生成
            MemoryMappedViewAccessor mmva = mmf.CreateViewAccessor();

            // 書き込みオブジェクトの現在のバイト位置
            int i = 0;

            // 書き込み１回目
            // 共有メモリの状態
            // |int(オブジェクトの数)|char［］(Hello )|
            string str1 = "Hello ";
            char［］ data1 = str1.ToCharArray();
            mmva.Write(i, data1.Length);
            i = i + sizeof(int);
            mmva.WriteArray&lt;char>(i, data1, 0, data1.Length);
            i = i + sizeof(char) * data1.Length;
            System.Threading.Thread.Sleep(1000);

            // 書き込み２回目
            // 共有メモリの状態
            // |(１回目の内容)|int(オブジェクトの数)|char［］(World)|
            string str2 = "World";
            char［］ data2 = str2.ToCharArray();
            mmva.Write(i, data2.Length);
            i = i + sizeof(int);
            mmva.WriteArray＜char＞(i, data2, 0, data2.Length);
            i = i + sizeof(char) * data2.Length;
            System.Threading.Thread.Sleep(1000);

            // 書き込み３回目
            // 共有メモリの状態
            // |(１～２回目の内容)|int(オブジェクトの数)|char［］(!)|
            string str3 = "!";
            char［］ data3 = str3.ToCharArray();
            mmva.Write(i, data3.Length);
            i = i + sizeof(int);
            mmva.WriteArray＜char＞(i, data3, 0, data3.Length);
            i = i + sizeof(char) * data3.Length;
            System.Threading.Thread.Sleep(1000);

            // 書き込みオブジェクトの破棄
            mmva.Dispose();

            // 共有メモリの破棄
            mmf.Dispose();
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.IO.MemoryMappedFiles;

namespace Sender

{

class Sender

{

// 本当はMutex等で排他制御するべき

static void Main(string［］ args)

{

// 共有メモリの作成("HelloWorld"という名前で1024バイトで定義)

MemoryMappedFile mmf =

MemoryMappedFile.CreateNew("HelloWorld", 1024);

// 書き込みオブジェクトの生成

MemoryMappedViewAccessor mmva = mmf.CreateViewAccessor();

// 書き込みオブジェクトの現在のバイト位置

int i = 0;

// 書き込み１回目

// 共有メモリの状態

// |int(オブジェクトの数)|char［］(Hello )|

string str1 = "Hello ";

char［］ data1 = str1.ToCharArray();

mmva.Write(i, data1.Length);

i = i + sizeof(int);

mmva.WriteArray<char>(i, data1, 0, data1.Length);

i = i + sizeof(char) * data1.Length;

System.Threading.Thread.Sleep(1000);

// 書き込み２回目

// 共有メモリの状態

// |(１回目の内容)|int(オブジェクトの数)|char［］(World)|

string str2 = "World";

char［］ data2 = str2.ToCharArray();

mmva.Write(i, data2.Length);

i = i + sizeof(int);

mmva.WriteArray＜char＞(i, data2, 0, data2.Length);

i = i + sizeof(char) * data2.Length;

System.Threading.Thread.Sleep(1000);

// 書き込み３回目

// 共有メモリの状態

// |(１～２回目の内容)|int(オブジェクトの数)|char［］(!)|

string str3 = "!";

char［］ data3 = str3.ToCharArray();

mmva.Write(i, data3.Length);

i = i + sizeof(int);

mmva.WriteArray＜char＞(i, data3, 0, data3.Length);

i = i + sizeof(char) * data3.Length;

System.Threading.Thread.Sleep(1000);

// 書き込みオブジェクトの破棄

mmva.Dispose();

// 共有メモリの破棄

mmf.Dispose();

}

・Receiver.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO.MemoryMappedFiles;

namespace Receiver
{
    class Receiver
    {
        // 本当はMutex等で排他制御するべき
        static void Main(string［］ args)
        {
            // 作成済み共有メモリ（"HelloWorld"）のオブジェクト生成
            MemoryMappedFile mmf = 
                MemoryMappedFile.OpenExisting("HelloWorld");
            
            // 読み込みオブジェクトの生成
            MemoryMappedViewAccessor mmva = mmf.CreateViewAccessor();

            // 読み込みオブジェクトの現在のバイト位置
            int i = 0;

            // 読み込み
            // オブジェクトの数が書き込まれていたらその分データを読む
            int size = 0;
            string str = "";
            while (!str.Equals("!"))
            {
                size = mmva.ReadInt32(i);
                if (size != 0)
                {
                    char［］ data = new char［size］;
                    i = i + sizeof(int);
                    mmva.ReadArray＜char＞(i, data, 0, data.Length);
                    str = new string(data);
                    Console.WriteLine(str);
                    i = i + sizeof(char) * data.Length;
                }
                System.Threading.Thread.Sleep(100);
            }
            
            // 読み込みオブジェクトの破棄
            mmva.Dispose();
            
            // コンソール表示を維持
            Console.ReadKey();
        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

using System.IO.MemoryMappedFiles;

namespace Receiver

{

class Receiver

{

// 本当はMutex等で排他制御するべき

static void Main(string［］ args)

{

// 作成済み共有メモリ（"HelloWorld"）のオブジェクト生成

MemoryMappedFile mmf =

MemoryMappedFile.OpenExisting("HelloWorld");

// 読み込みオブジェクトの生成

MemoryMappedViewAccessor mmva = mmf.CreateViewAccessor();

// 読み込みオブジェクトの現在のバイト位置

int i = 0;

// 読み込み

// オブジェクトの数が書き込まれていたらその分データを読む

int size = 0;

string str = "";

while (!str.Equals("!"))

{

size = mmva.ReadInt32(i);

if (size != 0)

{

char［］ data = new char［size］;

i = i + sizeof(int);

mmva.ReadArray＜char＞(i, data, 0, data.Length);

str = new string(data);

Console.WriteLine(str);

i = i + sizeof(char) * data.Length;

}

System.Threading.Thread.Sleep(100);

}

// 読み込みオブジェクトの破棄

mmva.Dispose();

// コンソール表示を維持

Console.ReadKey();

}

【実行バッチ】

・test.bat

C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe Sender.cs
C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe Receiver.cs
start Sender.exe
timeout 1
start Receiver.exe
pause
exit

C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe Sender.cs

C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe Receiver.cs

start Sender.exe

timeout 1

start Receiver.exe

pause

exit

【実行結果】

・Receiverのコンソール

Hello
World
!

Hello

World

いかがでしたでしょうか。

今回は、共有メモリを用いたデータの受け渡しを紹介してみました。
記事ではjavaに書き方が近く理解しやすいC#で書きましたが、本当に性能が求められる場合はCやC++で書く場合が多いです。
しかし、その場合もロジックは同じなので、参考になるのではないかと思います。