テックメモ – 当ブログは自分用のメモです。昔のメモをそのまま移行しただけの記事もあり一部不正確な記述もあります。

2019-09-17

C# DirectX基本色々

using System;
using System.Drawing;
using System.Windows.Forms;

using Microsoft.DirectX;
using Microsoft.DirectX.Direct3D;

namespace WindowsFormsApp5
{
    public partial class Form1 : Form
    {
        private Device device = null;
        private Microsoft.DirectX.Direct3D.Font _font = null; // Direct3DX

        public Form1()
        {
            InitializeComponent();
            this.ClientSize = new Size(640, 480);

            // デバイス初期化
            SetupDevice(this);

            // マウスイベントで描画
            this.MouseMove += MainRender;

            // 処理ループの場合
            while (this.Created)
            {
                System.Threading.Thread.Sleep(1);
                Application.DoEvents();
            }
        }
        private void MainRender(object sender, EventArgs e)
        {
            device.Clear(
                ClearFlags.Target, // クリアするターゲット
                Color.Blue,
                1.0f,
                0);

            device.BeginScene();

            // 図形描画1
            DrawVertex(CreateVertex());

            // 図形描画2
            DrawMesh();

            // 文字列描画
            DrawText();

            device.EndScene();
            device.Present();
        }

        private void DrawMesh()
        {
            Material material = new Material();
            material.Ambient = Color.Red;
            material.Diffuse = Color.AliceBlue;

            device.Material = material;

            // レンダリングオプション
            device.RenderState.ZBufferEnable = true;

            // カメラ
            device.Transform.View = Matrix.LookAtLH(
                new Vector3(5,5,-10), // カメラの位置
                new Vector3(0,0,0), // カメラの向いている方向
                new Vector3(0,1,0)); // 空間の上を示す方向

            // 投影変換
            device.Transform.Projection = Matrix.PerspectiveFovLH(
                (float)Math.PI/4, // 視界の広さ
                1.0F,
                1.0F,
                100.0F);

            // 照明
            device.Lights[0].Type = LightType.Directional;
            device.Lights[0].Direction = new Vector3(1, -1, 1);
            device.Lights[0].Diffuse = Color.FromArgb(255, 255, 255);
            device.Lights[0].Enabled = true;

            var mesh = Mesh.Box(device, 5, 5, 5);
            mesh.DrawSubset(0);
        }

        private void DrawText()
        {
            FontDescription fd = new FontDescription();
            fd.Height = 24;
            fd.FaceName = "ＭＳ ゴシック";

            _font = new Microsoft.DirectX.Direct3D.Font(device, fd);
            _font.DrawText(
                null, // Spriteクラスの使用有無
                "テスト", 
                PointToClient(MousePosition).X,
                PointToClient(MousePosition).Y,
                Color.White);
        }

        public CustomVertex.TransformedColoredTextured[] CreateVertex()
        {
            int mouseX = PointToClient(MousePosition).X;
            int mouseY = PointToClient(MousePosition).Y;
            int width = 200;
            int height = 100;

            // TransformedColoredTextured
            // 頂点データ作成
            // 頂点の型 (2Dの座標、色、テクスチャの座標を保持)

            var verts = new CustomVertex.TransformedColoredTextured[4];

            // 左上
            verts[0].X = mouseX;
            verts[0].Y = mouseY;
            verts[0].Tu = 0.0f;
            verts[0].Tv = 1.0f;
            verts[0].Color = Color.Green.ToArgb();

            // 右上
            verts[1].X = mouseX + width;
            verts[1].Y = mouseY;
            verts[1].Tu = 0.0f;
            verts[1].Tv = 1.0f;

            // 左下
            verts[2].X = mouseX;
            verts[2].Y = mouseY + height;
            verts[2].Tu = 0.0f;
            verts[2].Tv = 1.0f;

            // 右下
            verts[3].X = mouseX + width;
            verts[3].Y = mouseY + height;
            verts[3].Tu = 0.0f;
            verts[3].Tv = 1.0f;

            return verts;
        }

        private void DrawVertex(CustomVertex.TransformedColoredTextured[] verts)
        {
            // 頂点配列を頂点バッファへ

            if (device == null) return;

            VertexBuffer vertexBuffer = new VertexBuffer(
                typeof(CustomVertex.TransformedColoredTextured),
                4,
                device,
                0,
                CustomVertex.TransformedColoredTextured.Format,
                Pool.Managed);

            GraphicsStream stm = vertexBuffer.Lock(0, 0, 0);
            stm.Write(verts);
            vertexBuffer.Unlock();
            device.SetStreamSource(0, vertexBuffer, 0);
            device.VertexFormat = CustomVertex.TransformedColoredTextured.Format;
            device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);
        }

        public void SetupDevice(Control target)
        {
            PresentParameters pp = new PresentParameters();
            pp.Windowed = true;
            pp.SwapEffect = SwapEffect.Discard;
            pp.PresentationInterval = PresentInterval.Immediate;

            // 通常ハードウェア処理の方が高性能だかグラフィックカードなどにより要変更

            device = new Device(
                0, // 物理デバイスインデックス(通常0)
                DeviceType.Hardware,　// ハードウェアアクセラレーション有効化
                target,
                CreateFlags.HardwareVertexProcessing, // ハードウェアによる頂点処理有効化
                pp);
        }
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

using System;

using System.Drawing;

using System.Windows.Forms;

using Microsoft.DirectX;

using Microsoft.DirectX.Direct3D;

namespace WindowsFormsApp5

{

public partial class Form1 : Form

{

private Device device = null;

private Microsoft.DirectX.Direct3D.Font _font = null; // Direct3DX

public Form1()

{

InitializeComponent();

this.ClientSize = new Size(640, 480);

// デバイス初期化

SetupDevice(this);

// マウスイベントで描画

this.MouseMove += MainRender;

// 処理ループの場合

while (this.Created)

{

System.Threading.Thread.Sleep(1);

Application.DoEvents();

}

private void MainRender(object sender, EventArgs e)

{

device.Clear(

ClearFlags.Target, // クリアするターゲット

Color.Blue,

1.0f,

0);

device.BeginScene();

// 図形描画1

DrawVertex(CreateVertex());

// 図形描画2

DrawMesh();

// 文字列描画

DrawText();

device.EndScene();

device.Present();

}

private void DrawMesh()

{

Material material = new Material();

material.Ambient = Color.Red;

material.Diffuse = Color.AliceBlue;

device.Material = material;

// レンダリングオプション

device.RenderState.ZBufferEnable = true;

// カメラ

device.Transform.View = Matrix.LookAtLH(

new Vector3(5,5,-10), // カメラの位置

new Vector3(0,0,0), // カメラの向いている方向

new Vector3(0,1,0)); // 空間の上を示す方向

// 投影変換

device.Transform.Projection = Matrix.PerspectiveFovLH(

(float)Math.PI/4, // 視界の広さ

1.0F,

100.0F);

// 照明

device.Lights[0].Type = LightType.Directional;

device.Lights[0].Direction = new Vector3(1, -1, 1);

device.Lights[0].Diffuse = Color.FromArgb(255, 255, 255);

device.Lights[0].Enabled = true;

var mesh = Mesh.Box(device, 5, 5, 5);

mesh.DrawSubset(0);

}

private void DrawText()

{

FontDescription fd = new FontDescription();

fd.Height = 24;

fd.FaceName = "ＭＳゴシック";

_font = new Microsoft.DirectX.Direct3D.Font(device, fd);

_font.DrawText(

null, // Spriteクラスの使用有無

"テスト",

PointToClient(MousePosition).X,

PointToClient(MousePosition).Y,

Color.White);

}

public CustomVertex.TransformedColoredTextured[] CreateVertex()

{

int mouseX = PointToClient(MousePosition).X;

int mouseY = PointToClient(MousePosition).Y;

int width = 200;

int height = 100;

// TransformedColoredTextured

// 頂点データ作成

// 頂点の型 (2Dの座標、色、テクスチャの座標を保持)

var verts = new CustomVertex.TransformedColoredTextured[4];

// 左上

verts[0].X = mouseX;

verts[0].Y = mouseY;

verts[0].Tu = 0.0f;

verts[0].Tv = 1.0f;

verts[0].Color = Color.Green.ToArgb();

// 右上

verts[1].X = mouseX + width;

verts[1].Y = mouseY;

verts[1].Tu = 0.0f;

verts[1].Tv = 1.0f;

// 左下

verts[2].X = mouseX;

verts[2].Y = mouseY + height;

verts[2].Tu = 0.0f;

verts[2].Tv = 1.0f;

// 右下

verts[3].X = mouseX + width;

verts[3].Y = mouseY + height;

verts[3].Tu = 0.0f;

verts[3].Tv = 1.0f;

return verts;

}

private void DrawVertex(CustomVertex.TransformedColoredTextured[] verts)

{

// 頂点配列を頂点バッファへ

if (device == null) return;

VertexBuffer vertexBuffer = new VertexBuffer(

typeof(CustomVertex.TransformedColoredTextured),

device,

CustomVertex.TransformedColoredTextured.Format,

Pool.Managed);

GraphicsStream stm = vertexBuffer.Lock(0, 0, 0);

stm.Write(verts);

vertexBuffer.Unlock();

device.SetStreamSource(0, vertexBuffer, 0);

device.VertexFormat = CustomVertex.TransformedColoredTextured.Format;

device.DrawPrimitives(PrimitiveType.TriangleStrip, 0, 2);

}

public void SetupDevice(Control target)

{

PresentParameters pp = new PresentParameters();

pp.Windowed = true;

pp.SwapEffect = SwapEffect.Discard;

pp.PresentationInterval = PresentInterval.Immediate;

// 通常ハードウェア処理の方が高性能だかグラフィックカードなどにより要変更

device = new Device(

0, // 物理デバイスインデックス(通常0)

DeviceType.Hardware,　// ハードウェアアクセラレーション有効化

target,

CreateFlags.HardwareVertexProcessing, // ハードウェアによる頂点処理有効化

pp);

}

2019-09-13

C# DI/DIP

using System;
using System.Windows.Forms;

namespace WindowsFormsApp1
{
    public partial class Form1 : Form
    {
        public Form1(IDo d)
        {
            // この場合、Main > A > B という依存関係がある。
            new A().Do();

            // Main > IDo < A > B という依存関係に切り替える。
            d.Do();

            // コンストラクタ経由にし(DI)直接Aを生成しないためMainはAに依存せずIDoに依存。
            // IDoはレイヤー的に考えるとMainと同レイヤーであり、 
            // AもIDoに依存(制約)している。(依存性逆転=DIP)
            
        }
    }
    public interface IDo { void Do(); }

    // --------------------------------------------------------

    class A : IDo
    {
        public void Do()
        {
            new B().Do();
        }
    }

    class B
    {
        public void Do()
        {
            MessageBox.Show("work");
        }
    }
}

using System;

using System.Windows.Forms;

namespace WindowsFormsApp1

{

public partial class Form1 : Form

{

public Form1(IDo d)

{

// この場合、Main > A > B という依存関係がある。

new A().Do();

// Main > IDo < A > B という依存関係に切り替える。

d.Do();

// コンストラクタ経由にし(DI)直接Aを生成しないためMainはAに依存せずIDoに依存。

// IDoはレイヤー的に考えるとMainと同レイヤーであり、

// AもIDoに依存(制約)している。(依存性逆転=DIP)

}

public interface IDo { void Do(); }

// --------------------------------------------------------

class A : IDo

{

public void Do()

{

new B().Do();

}

class B

{

public void Do()

{

MessageBox.Show("work");

}

2019-09-132019-09-14

C# 関心分離(作ると使うを分ける)

using System;
using System.Windows.Forms;

namespace WindowsFormsApp1
{
    public partial class Form1 : Form
    {
        public Form1() // Main
        {
            InitializeComponent();

            // Mainでオブジェクトを生成しAppに渡す。
            // 作ると使うを分離する。
            var obj = new Builder().CreateObj();
            new App(obj).work();

            // 利用側で作るをコントロールしたい場合
            new App(new Builder2()).work2();
        }
    }

    interface IFactory { Object CreateObj(); }

    // 作る側
    class Builder2 : IFactory
    {
        public object CreateObj() { return new Object(); }
    }

    class Builder : IFactory
    {
        public object CreateObj() { return new Object(); }
    }

    // 使う側
    class App
    {
        private object _o;
        public App(object o)
        {
            _o = o;
        }
        public void work()
        {
            MessageBox.Show("work");
        }

        // --------------------------------------------------------
        // Appはインスタンスを自分のタイミングで生成できる。
        // 実装の詳細は管理する必要ない。

        public App(IFactory f)
        {
            _o = f.CreateObj();
        }
        public void work2()
        {
            MessageBox.Show("work2");
        }
    }
}

using System;

using System.Windows.Forms;

namespace WindowsFormsApp1

{

public partial class Form1 : Form

{

public Form1() // Main

{

InitializeComponent();

// Mainでオブジェクトを生成しAppに渡す。

// 作ると使うを分離する。

var obj = new Builder().CreateObj();

new App(obj).work();

// 利用側で作るをコントロールしたい場合

new App(new Builder2()).work2();

}

interface IFactory { Object CreateObj(); }

// 作る側

class Builder2 : IFactory

{

public object CreateObj() { return new Object(); }

}

class Builder : IFactory

{

public object CreateObj() { return new Object(); }

}

// 使う側

class App

{

private object _o;

public App(object o)

{

_o = o;

}

public void work()

{

MessageBox.Show("work");

}

// --------------------------------------------------------

// Appはインスタンスを自分のタイミングで生成できる。

// 実装の詳細は管理する必要ない。

public App(IFactory f)

{

_o = f.CreateObj();

}

public void work2()

{

MessageBox.Show("work2");

}

2019-09-112019-09-17

C# DirectX第一歩

DirectX Software Development Kit (SDK)
のインストールが必要な場合、
そのままインストールすると失敗するので、
Microsoft Visual C++ 関連を全て削除してからインストールする。
(2010が原因の模様で2010だけでもいけるっぽい)

public partial class Form1 : Form
{
private Device device = null;
public Form1()
{
    // 参照設定でDLL追加
    // C:\Windows\assembly\GAC\Microsoft.DirectX

    // app.configを以下の用に書き換える
    // <startup> を下記のように変更 
    // <startup useLegacyV2RuntimeActivationPolicy="true">

    // デバッグ > ウィンドウ > 例外設定
    // Managed Debugging Assistants > LoaderLockのチェックを外す。

    InitializeComponent();

    PresentParameters pp = new PresentParameters();
    pp.Windowed = true;
    pp.SwapEffect = SwapEffect.Discard;

    device = new Device(
        0,
        DeviceType.Hardware,
        this,
        CreateFlags.SoftwareVertexProcessing, pp);

    this.Paint += (s, e) =>
    {
        device.Clear(
            ClearFlags.Target,
            Color.DarkBlue,
            1.0f,
            0);
        device.BeginScene();
        device.EndScene();
        device.Present();
    };

    this.FormClosed += (s, e) =>
    {
        device.Dispose();
        device = null;
    };

}
}

public partial class Form1 : Form

{

private Device device = null;

public Form1()

{

// 参照設定でDLL追加

// C:\Windows\assembly\GAC\Microsoft.DirectX

// app.configを以下の用に書き換える

// <startup> を下記のように変更

// <startup useLegacyV2RuntimeActivationPolicy="true">

// デバッグ > ウィンドウ > 例外設定

// Managed Debugging Assistants > LoaderLockのチェックを外す。

InitializeComponent();

PresentParameters pp = new PresentParameters();

pp.Windowed = true;

pp.SwapEffect = SwapEffect.Discard;

device = new Device(

DeviceType.Hardware,

this,

CreateFlags.SoftwareVertexProcessing, pp);

this.Paint += (s, e) =>

{

device.Clear(

ClearFlags.Target,

Color.DarkBlue,

1.0f,

0);

device.BeginScene();

device.EndScene();

device.Present();

};

this.FormClosed += (s, e) =>

{

device.Dispose();

device = null;

};

}

2019-09-11

C# 非同期Thread/ThreadPool

public Form1()
{
    InitializeComponent();

    // Thread メソッド
    var t1 = new System.Threading.Thread(Test1);
    t1.Start();

    // Thread ラムダ
    new System.Threading.Thread(() =>
    {
        MessageBox.Show("hello world1");

        this.Invoke((Action)(()=> {
            button1.Text = "1";
        }));
        // 別スレッドからUIにアクセスする場合、Invokeから

    }).Start();

    // スレッドは高コストなので使い回す。ThreadPool

    System.Threading.ThreadPool.QueueUserWorkItem( _ =>
    {
        MessageBox.Show("hello world2");
    }, null);
    // QueueUserWorkItem
    // QueueUserWorkItem(実行するメソッド, メソッドの引数)
    // 実行するメソッドはWaitCallbackデリゲート型 = delegate void WaitCallback (Object state)
}

private void Test1() { }

public Form1()

{

InitializeComponent();

// Thread メソッド

var t1 = new System.Threading.Thread(Test1);

t1.Start();

// Thread ラムダ

new System.Threading.Thread(() =>

{

MessageBox.Show("hello world1");

this.Invoke((Action)(()=> {

button1.Text = "1";

}));

// 別スレッドからUIにアクセスする場合、Invokeから

}).Start();

// スレッドは高コストなので使い回す。ThreadPool

System.Threading.ThreadPool.QueueUserWorkItem( _ =>

{

MessageBox.Show("hello world2");

}, null);

// QueueUserWorkItem

// QueueUserWorkItem(実行するメソッド, メソッドの引数)

// 実行するメソッドはWaitCallbackデリゲート型 = delegate void WaitCallback (Object state)

}

private void Test1() { }

2019-09-102019-09-11

C# 非同期async/await(TAP)

public Form1()
{
    // TAPはTask/Task<T>を利用した(返す)パターンで
    // 言語機能でTAPをサポートしたのがasync/await文

    // Task
    // Task.Run=ワーカースレッド起動 (タスク実行用のスレッド=ワーカースレッド)
    // Taskによって非同期I/Oもワーカースレッドも共通の管理ができる。
    // 昔は、Task.Factory.StartNewとしていた。
    // Task.RunはTask生成と実行を同時に行う。内部的にはThreadPoolを利用している。
    // Threadクラスを使えば、直接ワーカースレッドを操作することもできる。

    // --------------------------------------------------------
    // ContinueWith

    var byteString1 = Encoding.UTF8.GetBytes("Hello");
    System.IO.MemoryStream ms = new System.IO.MemoryStream();

    var task = ms.WriteAsync(byteString1, 0, byteString1.Length);
    task.ContinueWith(ContinueAction);

    System.Threading.Thread.Sleep(3000);

    MessageBox.Show("2");

    // 1 > 2の順番で別スレットで表示される
    // WriteAsyncで作られた別スレッドを継続するので1と2が同時に表示される
    // ContinueWithで継続処理を記入

    // --------------------------------------------------------
    // async/await

    // 通常はxxxTaskAsync()というメソッド呼ぶときにawaitで別スレッド化し、
    // awaitを含んだメソッドはasyncを付け、返り値をTask<T>とする。

    Task<string> str1 = Test1();
    MessageBox.Show(str1.Result + "3");
    // Test1()はawaitで待機していないがResultを取得すると自動で待機する。

    Test2();
}
async private Task<string> Test1()
{
    string str = await Task.Run(() => {
        System.Threading.Thread.Sleep(3000);
        return "hello";
    }).ConfigureAwait(false); // これがないとResultで固まる。
    return str;
}

async private void Test2()
{
    string s = await TestAsync();
    MessageBox.Show(s.ToString());

    // 上記のようにResult取得でも待機するが、awaitで待機することもできる。
    // 基本的にxxxAsyncはawaitで待ち受ける。wait等を使うとデットロックする。
}

async private Task<string> TestAsync()
{
    string s = await Task.Run(()=> {
        return "done";
    });
    return s;
}

private void ContinueAction(Task t)
{
    MessageBox.Show("1");
}

public Form1()

{

// TAPはTask/Task<T>を利用した(返す)パターンで

// 言語機能でTAPをサポートしたのがasync/await文

// Task

// Task.Run=ワーカースレッド起動 (タスク実行用のスレッド=ワーカースレッド)

// Taskによって非同期I/Oもワーカースレッドも共通の管理ができる。

// 昔は、Task.Factory.StartNewとしていた。

// Task.RunはTask生成と実行を同時に行う。内部的にはThreadPoolを利用している。

// Threadクラスを使えば、直接ワーカースレッドを操作することもできる。

// --------------------------------------------------------

// ContinueWith

var byteString1 = Encoding.UTF8.GetBytes("Hello");

System.IO.MemoryStream ms = new System.IO.MemoryStream();

var task = ms.WriteAsync(byteString1, 0, byteString1.Length);

task.ContinueWith(ContinueAction);

System.Threading.Thread.Sleep(3000);

MessageBox.Show("2");

// 1 > 2の順番で別スレットで表示される

// WriteAsyncで作られた別スレッドを継続するので1と2が同時に表示される

// ContinueWithで継続処理を記入

// --------------------------------------------------------

// async/await

// 通常はxxxTaskAsync()というメソッド呼ぶときにawaitで別スレッド化し、

// awaitを含んだメソッドはasyncを付け、返り値をTask<T>とする。

Task<string> str1 = Test1();

MessageBox.Show(str1.Result + "3");

// Test1()はawaitで待機していないがResultを取得すると自動で待機する。

Test2();

}

async private Task<string> Test1()

{

string str = await Task.Run(() => {

System.Threading.Thread.Sleep(3000);

return "hello";

}).ConfigureAwait(false); // これがないとResultで固まる。

return str;

}

async private void Test2()

{

string s = await TestAsync();

MessageBox.Show(s.ToString());

// 上記のようにResult取得でも待機するが、awaitで待機することもできる。

// 基本的にxxxAsyncはawaitで待ち受ける。wait等を使うとデットロックする。

}

async private Task<string> TestAsync()

{

string s = await Task.Run(()=> {

return "done";

});

return s;

}

private void ContinueAction(Task t)

{

MessageBox.Show("1");

}

public Form1()
{
    Test2();
    MessageBox.Show("main");
}

async private void Test2()
{
    string s = await TestAsync2();
    // awaitはTaskに付ける = awaitはAwaitableに付ける
    // AwaitableはGetAwaiterメソッドを持ちTaskはGetAwaiterを持っている。

}

async private Task<string> TestAsync1()
{
    string s = await Task.Run(()=> {
        return "done";
    });
    return s;
}

private Task<string> TestAsync2()
{
    MessageBox.Show("async"); // この位置だと別スレッド化しない。

    Task<string> t = Task.Run(() => {

        MessageBox.Show("async");
        // この位置だと別スレッド化する。
        
        return "done";
    });
    return t;
    // awaitを付けるとTask<T>ではなくTで受けれる。
    // 実態はTask。awaitはTaskに付けれるので。

    // asyncが付いている場合、定義の返り値はTask<T>だけど、return TでOK。
    // asyncが付いていないと、そのまま通常通り。
    // Taskを返り値で定義しているならreturn taskとしないとダメ。
}

public Form1()

{

Test2();

MessageBox.Show("main");

}

async private void Test2()

{

string s = await TestAsync2();

// awaitはTaskに付ける = awaitはAwaitableに付ける

// AwaitableはGetAwaiterメソッドを持ちTaskはGetAwaiterを持っている。

}

async private Task<string> TestAsync1()

{

string s = await Task.Run(()=> {

return "done";

});

return s;

}

private Task<string> TestAsync2()

{

MessageBox.Show("async"); // この位置だと別スレッド化しない。

Task<string> t = Task.Run(() => {

MessageBox.Show("async");

// この位置だと別スレッド化する。

return "done";

});

return t;

// awaitを付けるとTask<T>ではなくTで受けれる。

// 実態はTask。awaitはTaskに付けれるので。

// asyncが付いている場合、定義の返り値はTask<T>だけど、return TでOK。

// asyncが付いていないと、そのまま通常通り。

// Taskを返り値で定義しているならreturn taskとしないとダメ。

}

public Form1()
{
    Test2();
    MessageBox.Show("main");
}

async private void Test2()
{
    string s = await TestAsync2();
    // awaitはTaskに付ける = awaitはAwaitableに付ける
    // AwaitableはGetAwaiterメソッドを持つ必要があり、TaskはGetAwaiterを持っている。
    // AwaiterはIsCompleted,GetResult,OnCompletedを持つ。

    // awaitしているメソッド(TestAsync)のOnCompletedイベントに対して、
    // asyncしているメソッド(Test2)を登録する。
    // OnCompletedからコールバックで呼ばれる自分自身(Test2)は
    // await以降の処理をするように条件分岐される。
}

private Task<string> TestAsync2()
{
    Task<string> t = Task.Run(() => {
        return "done";
    });
    return t;
}

public Form1()

{

Test2();

MessageBox.Show("main");

}

async private void Test2()

{

string s = await TestAsync2();

// awaitはTaskに付ける = awaitはAwaitableに付ける

// AwaitableはGetAwaiterメソッドを持つ必要があり、TaskはGetAwaiterを持っている。

// AwaiterはIsCompleted,GetResult,OnCompletedを持つ。

// awaitしているメソッド(TestAsync)のOnCompletedイベントに対して、

// asyncしているメソッド(Test2)を登録する。

// OnCompletedからコールバックで呼ばれる自分自身(Test2)は

// await以降の処理をするように条件分岐される。

}

private Task<string> TestAsync2()

{

Task<string> t = Task.Run(() => {

return "done";

});

return t;

}

2019-09-092019-09-11

C# 非同期Async/Completed(EAP)

public Form1()
{
    System.Net.WebClient wc = new System.Net.WebClient();
    wc.DownloadStringCompleted += (s, e) =>
    {
        MessageBox.Show("done");
    };

    wc.DownloadStringAsync(new Uri("https://www.google.co.jp"));
}

public Form1()

{

System.Net.WebClient wc = new System.Net.WebClient();

wc.DownloadStringCompleted += (s, e) =>

{

MessageBox.Show("done");

};

wc.DownloadStringAsync(new Uri("https://www.google.co.jp"));

}

BackgroundWorker w = new BackgroundWorker();
public Form1()
{
    InitializeComponent();
    // xxxAsyncで実行、終了時にxxxCompletedのコールバック
    // BackgroundWorkerが標準でサポート

    w.DoWork += OnWork;
    w.RunWorkerCompleted += OnWorkCompleted;

    w.RunWorkerAsync();

    MessageBox.Show("end");
    // 待機がないとcompletedが表示される前にメインスレッドが終了する
}

private void OnWork(object sender, DoWorkEventArgs e)
{
    MessageBox.Show("work");
}
private void OnWorkCompleted(object sender, RunWorkerCompletedEventArgs e)
{
    MessageBox.Show("completed");
}

BackgroundWorker w = new BackgroundWorker();

public Form1()

{

InitializeComponent();

// xxxAsyncで実行、終了時にxxxCompletedのコールバック

// BackgroundWorkerが標準でサポート

w.DoWork += OnWork;

w.RunWorkerCompleted += OnWorkCompleted;

w.RunWorkerAsync();

MessageBox.Show("end");

// 待機がないとcompletedが表示される前にメインスレッドが終了する

}

private void OnWork(object sender, DoWorkEventArgs e)

{

MessageBox.Show("work");

}

private void OnWorkCompleted(object sender, RunWorkerCompletedEventArgs e)

{

MessageBox.Show("completed");

}

対応している型

System.ComponentModel.Component
System.ComponentModel.BackgroundWorker
System.Media.SoundPlayer
System.Net.WebClient
System.Net.NetworkInformation.Ping
System.Windows.Forms.PictureBox
System.Net.Mail.SmtpClient
System.Deployment.Application.ApplicationDeployment
System.Deployment.Application.InPlaceHostingManager
System.Activities.WorkflowInvoker
System.ServiceModel.Activities.WorkflowControlClient
System.Net.PeerToPeer.PeerNameResolver
System.Net.PeerToPeer.Collaboration.ContactManager
System.Net.PeerToPeer.Collaboration.Peer
System.Net.PeerToPeer.Collaboration.PeerContact
System.Net.PeerToPeer.Collaboration.PeerNearMe
System.ServiceModel.Discovery.AnnouncementClient
System.ServiceModel.Discovery.DiscoveryClient

2019-09-09

C# 動的に画像生成

public Form1()
{
    PictureBox pb = new PictureBox();
    pb.Image = MakePic();
    Controls.Add(pb);
}

private Bitmap MakePic()
{
    Bitmap b = new Bitmap(100, 100);
    Graphics g = Graphics.FromImage(b);
    g.FillRectangle(Brushes.Black, g.VisibleClipBounds);
    g.DrawPie(Pens.Red, 60, 10, 80, 80, 30, 300);
    g.Dispose();
    return b;
}

public Form1()

{

PictureBox pb = new PictureBox();

pb.Image = MakePic();

Controls.Add(pb);

}

private Bitmap MakePic()

{

Bitmap b = new Bitmap(100, 100);

Graphics g = Graphics.FromImage(b);

g.FillRectangle(Brushes.Black, g.VisibleClipBounds);

g.DrawPie(Pens.Red, 60, 10, 80, 80, 30, 300);

g.Dispose();

return b;

}

2019-09-092019-09-09

C# 非同期Begin/End(APM)

public Form1()
{
    var byteString = Encoding.UTF8.GetBytes("Hello World !!!");
    var ms = new System.IO.MemoryStream();
    ms.BeginWrite(byteString, 0, byteString.Length, CallBack, ms);
    // MemoryStreamに書き込み
    // Beginで別スレッド化
    // obj はコールバックに引き渡したい任意のオブジェクト 

    MessageBox.Show("終了");

    //while(!ar.IsCompleted) { }
    // コールバックを使わず。ステータスのポーリングでもOK
}
private void CallBack(IAsyncResult ar)
{
    // 処理が終わるとコールバックが呼ばれる。コールバックの中でEndを呼ぶ。

    var ms = (System.IO.MemoryStream)ar.AsyncState;
    ms.EndWrite(ar);
    var buf = ms.ToArray(); // MemoryStreamをバイト配列へ

    System.Threading.Thread.Sleep(2000);

    MessageBox.Show(Encoding.UTF8.GetString(buf));
}

public Form1()

{

var byteString = Encoding.UTF8.GetBytes("Hello World !!!");

var ms = new System.IO.MemoryStream();

ms.BeginWrite(byteString, 0, byteString.Length, CallBack, ms);

// MemoryStreamに書き込み

// Beginで別スレッド化

// obj はコールバックに引き渡したい任意のオブジェクト

MessageBox.Show("終了");

//while(!ar.IsCompleted) { }

// コールバックを使わず。ステータスのポーリングでもOK

}

private void CallBack(IAsyncResult ar)

{

// 処理が終わるとコールバックが呼ばれる。コールバックの中でEndを呼ぶ。

var ms = (System.IO.MemoryStream)ar.AsyncState;

ms.EndWrite(ar);

var buf = ms.ToArray(); // MemoryStreamをバイト配列へ

System.Threading.Thread.Sleep(2000);

MessageBox.Show(Encoding.UTF8.GetString(buf));

}

対応している型

System.IO.Stream
System.IO.Ports.SerialPort
System.Net.Dns
System.Net.Sockets.Socket
System.Net.WebRequest
System.Data.SqlClient.SqlCommand

2019-09-062019-09-11

C# デリゲート(匿名メソッド・ラムダ式)

using System;
using System.Windows.Forms;

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

            // 最初の頃の書き方。
            MyFunc f1 = new MyFunc(SomeFunc1);

            // このように書けるようになる。
            MyFunc f2 = SomeFunc1;

            // 複数のメソッドを代入できる。
            MyFunc f3 = SomeFunc1;
            f3 += SomeFunc2;

            f3(""); // 1,2と表示される。

            // 非同期にできる。

            MyLoop myLoop = DoLoop1;

            IAsyncResult ar = myLoop.BeginInvoke(
                new AsyncCallback((IAsyncResult result) => {
                    MessageBox.Show("end");
                }), null);
            // BeginInvokeの1引数は完了時に実行されるコールバックメソッド

            MessageBox.Show("DoLoop待ち");
            myLoop.EndInvoke(ar);

            // DoLoop待ち > 1000000000 > end と表示される。
            // 1000000000はDoLoop待ちを待機しない。
            // endは1000000000を待つが、DoLoop待ちとは別スレッド。

            // --------------------------------------------------------

            // 匿名暗数(匿名メソッド・ラムダ式)

            // 匿名メソッド
            // メソッドを定義し参照する必要がなくなった、その場で定義できる

            Action<int> f4 = delegate (int x) 
            {
                MessageBox.Show((x * 2).ToString());
            };

            f4(4); // 8

            // ラムダ式では匿名メソッドが簡素化した。
            // 引数の型推論。returnや{}の省略。

            Action f5 = () => MessageBox.Show("ラムダ");
            f5(); // ラムダ
        }

        private int SomeFunc1(string s)
        {
            MessageBox.Show("1");
            return 1;
        }

        private int SomeFunc2(string s)
        {
            MessageBox.Show("2");
            return 2;
        }

        private void DoLoop1()
        {
            int i = 0;
            for (i = 0; i < 1000000000; i++) { }
            MessageBox.Show(i.ToString());
        }
    }

    // デリゲートとはメソッドを参照する型。
    // 型なのでクラスや構造体と同じ扱い。

    delegate int MyFunc(string s); // stringの引数でintの戻り値
    delegate void MyLoop(); // 引数無し、戻り値無し
}

using System;

using System.Windows.Forms;

namespace WindowsFormsApp1

{

public partial class Form1 : Form

{

public Form1()

{

InitializeComponent();

// 最初の頃の書き方。

MyFunc f1 = new MyFunc(SomeFunc1);

// このように書けるようになる。

MyFunc f2 = SomeFunc1;

// 複数のメソッドを代入できる。

MyFunc f3 = SomeFunc1;

f3 += SomeFunc2;

f3(""); // 1,2と表示される。

// 非同期にできる。

MyLoop myLoop = DoLoop1;

IAsyncResult ar = myLoop.BeginInvoke(

new AsyncCallback((IAsyncResult result) => {

MessageBox.Show("end");

}), null);

// BeginInvokeの1引数は完了時に実行されるコールバックメソッド

MessageBox.Show("DoLoop待ち");

myLoop.EndInvoke(ar);

// DoLoop待ち > 1000000000 > end と表示される。

// 1000000000はDoLoop待ちを待機しない。

// endは1000000000を待つが、DoLoop待ちとは別スレッド。

// --------------------------------------------------------

// 匿名暗数(匿名メソッド・ラムダ式)

// 匿名メソッド

// メソッドを定義し参照する必要がなくなった、その場で定義できる

Action<int> f4 = delegate (int x)

{

MessageBox.Show((x * 2).ToString());

};

f4(4); // 8

// ラムダ式では匿名メソッドが簡素化した。

// 引数の型推論。returnや{}の省略。

Action f5 = () => MessageBox.Show("ラムダ");

f5(); // ラムダ

}

private int SomeFunc1(string s)

{

MessageBox.Show("1");

return 1;

}

private int SomeFunc2(string s)

{

MessageBox.Show("2");

return 2;

}

private void DoLoop1()

{

int i = 0;

for (i = 0; i < 1000000000; i++) { }

MessageBox.Show(i.ToString());

}

// デリゲートとはメソッドを参照する型。

// 型なのでクラスや構造体と同じ扱い。

delegate int MyFunc(string s); // stringの引数でintの戻り値

delegate void MyLoop(); // 引数無し、戻り値無し

}

private void Test1()
{
    // 引数等でdelegateの型を受ける場合、ラムダを渡せない。
    // Action/Funcは定義済みデリゲート

    var f = (Action)(() => {
        MessageBox.Show("delegate");
    });

    f();

    // ラムダをdelegateに変換し即時実行。
    // 戻り値を渡すことができる。
    var a = ((Func<string>)(() => {
        return "a";
    }))();

}

private void Test1()

{

// 引数等でdelegateの型を受ける場合、ラムダを渡せない。

// Action/Funcは定義済みデリゲート

var f = (Action)(() => {

MessageBox.Show("delegate");

});

f();

// ラムダをdelegateに変換し即時実行。

// 戻り値を渡すことができる。

var a = ((Func<string>)(() => {

return "a";

}))();

}