米MS、NOKIAの携帯部門とその特許を買収とのこと

NOKIAはWindowsPhoneとしてLumiaシリーズを発売していましたが、この買収によって米MSが直接端末を販売する可能性が出てきました。
買収完了は2014年第一四半期のようですから、出るとしてもそれ以降かと思われますが、ホリデーシーズンにテコ入れということでMSがさらに押してくる可能性はありますね。

お願いしたいのは技適付きのWindowsPhone8端末を日本で販売してもらうことだけです。
なんとなくですが、今回の件が日本でWindowsPhone8端末(または噂されるWP8.1更新機)を販売する最後の機会なのかもしれないと思ってます。

米マイクロソフトのプレスリリース

Lumiaシリーズは日本のユーザーに受ける端末だと思うんですけどね、デザイン的にもシステム的にも、ただし、マップをゼンリンなどから供給してもらって表示できるようにならないと不評しか出ないでしょう。
大手のアプリはほぼそろっているので、その辺では問題ないと思いますが、ゲームが少し弱いかな?
なんとか出てほしい、、、

同じソリューションの別プロジェクトにあるファイルの読み込み

まあ、単純な事なんですが「ms-appx:///プロジェクトの名前/ファイルの名前」これだけです。
フォルダがあるならフォルダ名入れればOKです。

データを別なプロジェクトに逃がしておきたい、データとコードは分離したい等の時はプロジェクトの追加で、Windowsランタイムプロジェクトとして作成して参照しておく。

判り切ってることのネタですが、最近記事書いてなかったのでとりあえず書いてみました。

Xaudio2をC++/CXで作成

Windowsストアアプリで音を鳴らす場合、MediaElementが一般的ですが、画面の遷移がある場合などには少々向きません。
鳴らしたままなどであればやり方もあるんですが、デメリットとして、ボリューム変更などができなくなります。
SharpDXを使用すればC#でもXAudio2を使用可能ですが、今回のはC++/CXで作成したものです。
マイクロソフトのサンプルなどを参考にとりあえずのレベルですが、作成しました。
C#からもWindowsランタイムコンポーネントとして引き込むことで使用できます。

※各種サンプルを公開されている方々とマイクロソフトに感謝を

読み込んでいるヘッダーです

// Microsoft WRL(Windows ランタイム C++ テンプレート ライブラリ) 用ヘッダー
#include <wrl.h>
// XAudio2用ヘッダー
#include <xaudio2.h>
#include <xaudio2fx.h>
// マルチメディア用ヘッダー
#include <mmreg.h>
// media fusion 用ヘッダー
#include <Mfidl.h>
#include <Mfapi.h>
#include <Mfreadwrite.h>
/* 上記に必要なライブラリ
xaudio2.lib
mfcore.lib
mfplat.lib
mfreadwrite.lib
mfuuid.lib
*/
#include "pch.h"
#include "xaudiolib.h"

using namespace Microsoft::WRL;
using namespace Platform;

namespace xaudio2lib
{
	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// サウンドデータ
	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	// BGM管理構造体
	struct xaudiolib::ImplSoundData
	{
		ImplSoundData::ImplSoundData(Platform::String^ filename,xaudiolib^ parent,int index) :
			sourceVoice(nullptr),
			//playData(data),
			isPlaying(false),
			isLoop(false),
			audioFilePlayerCallBack(parent->m_musicEngine, filename, index)
		{
			sourceVoice = audioFilePlayerCallBack.GetSourceVoice();

		}

		~ImplSoundData()
		{
			if (sourceVoice)
			{
				sourceVoice->DestroyVoice();
				sourceVoice = nullptr;
			}
		}

		IXAudio2SourceVoice*    sourceVoice;
		bool                    isPlaying;
		bool					isLoop;
		AudioFilePlayerCallBack			audioFilePlayerCallBack;
	};

	struct xaudiolib::ImplSeData
	{
		ImplSeData::ImplSeData(Platform::String^ filename,xaudiolib^ parent,int index) :
			sourceVoice(nullptr),
			//playData(data),
			isPlaying(false),
			isLoop(false),
			audioFilePlayerCallBack(parent->m_seEngine, filename, index)
		{
			sourceVoice = audioFilePlayerCallBack.GetSourceVoice();
		}

		~ImplSeData()
		{
			if (sourceVoice)
			{
				sourceVoice->DestroyVoice();
				sourceVoice = nullptr;
			}
		}

		IXAudio2SourceVoice*    sourceVoice;
		bool                    isPlaying;
		bool					isLoop;
		AudioFilePlayerCallBack			audioFilePlayerCallBack;
	};

	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	xaudiolib::xaudiolib(void):m_soudBgmDataList(),m_soudSeDataList()
	{
		XAudio2Initialize();
	}


	xaudiolib::~xaudiolib(void)
	{
		seList.clear();
		bgmList.clear();

		XAudio2Clear();
	}

	void xaudiolib::AddBgmFileName(Platform::String^ _fileName)
	{
		bgmList.push_back(_fileName);
	}

	void xaudiolib::AddSeFileName(Platform::String^ _fileName)
	{
		seList.push_back(_fileName);
	}

	void xaudiolib::Initialize()
	{
	}

	void xaudiolib::XAudio2Initialize()
	{
		m_musicMasteringVoice = nullptr;
		m_audioAvailable = false;

		UINT32 flags = 0;

		// BGM用XAudio2ポインタ作成
		DX::ThrowIfFailed(
			XAudio2Create(&m_musicEngine, flags)
			);

		// BGM用ミキサーの作成
		HRESULT hr = m_musicEngine->CreateMasteringVoice(&m_musicMasteringVoice);
		if (FAILED(hr))
		{
			m_audioAvailable = false;
			return;
		}

		// SE用XAudio2ポインタ作成
		DX::ThrowIfFailed(
			XAudio2Create(&m_seEngine, flags)
			);

		// SE用ミキサーの作成
		hr = m_seEngine->CreateMasteringVoice(&m_seMasteringVoice);
		if (FAILED(hr))
		{
			m_audioAvailable = false;
			return;
		}

		m_audioAvailable = true;
	}

	void xaudiolib::XAudio2Clear()
	{
		if(m_audioAvailable)
		{
		for (size_t index = 0; index < bgmList.size(); ++index)
		{
			m_soudBgmDataList[index]->audioFilePlayerCallBack.AudioFilePlayerEnd(index);
		}

		for (size_t index = 0; index < seList.size(); ++index)
		{
			m_soudSeDataList[index]->audioFilePlayerCallBack.AudioFilePlayerEnd(index);
		}

		// マスターVoiceの解放
			m_musicMasteringVoice->DestroyVoice();
			m_musicMasteringVoice = nullptr;

			m_seMasteringVoice->DestroyVoice();
			m_seMasteringVoice = nullptr;

			// m_musicEngine/m_seEngineは「Microsoft::WRL::ComPtr」で自動的に開放

			m_audioAvailable = false;
		}
	}

	// サウンドデータを読み込む
	void xaudiolib::XAudio2Load()
	{
		for (size_t index = 0; index < bgmList.size(); ++index)
		{
			AddBgmSound(bgmList[index], index);
		}

		for (size_t index = 0; index < seList.size(); ++index)
		{
			AddSeSound(seList[index], index);
		}
	}

	// BGMデータを登録する
	size_t xaudiolib::AddBgmSound(_In_ Platform::String^ soundFileName, _In_ int index)
	{
		std::shared_ptr<ImplSoundData> implSoundData(new ImplSoundData(soundFileName,this,index));

		m_soudBgmDataList.push_back(implSoundData);
		return (m_soudBgmDataList.size() - 1);
	}

	// SEデータを登録する
	size_t xaudiolib::AddSeSound(_In_ Platform::String^ seFileName, _In_ int index)
	{
		std::shared_ptr<ImplSeData> implSeData(new ImplSeData(seFileName,this,index));

		m_soudSeDataList.push_back(implSeData);
		return (m_soudSeDataList.size() - 1);
	}


	bool xaudiolib::IsBgmPlay(int bgmIndex, bool bLoop)
	{

		if(!m_audioAvailable)
		{
			return false;
		}

		m_soudBgmDataList[bgmIndex]->audioFilePlayerCallBack.IsPlay(bLoop, bgmIndex);

		return true;
	}

	bool xaudiolib::IsBgmStop(int bgmIndex)
	{

		if(!m_audioAvailable)
		{
			return false;
		}

		m_soudBgmDataList[bgmIndex]->audioFilePlayerCallBack.IsStop();

		return true;
	}

	bool xaudiolib::IsSePlay(int seIndex)
	{

		if(!m_audioAvailable)
		{
			return false;
		}

		m_soudSeDataList[seIndex]->audioFilePlayerCallBack.IsPlay(false, seIndex);

		return true;
	}

	bool xaudiolib::IsSeStop(int seIndex)
	{

		if(!m_audioAvailable)
		{
			return false;
		}

		m_soudSeDataList[seIndex]->audioFilePlayerCallBack.IsStop();

		return true;
	}

	bool xaudiolib::IsBgmPlaying(int bgmIndex)
	{
		if(!m_audioAvailable)
		{
			return false;
		}

		return m_soudBgmDataList[bgmIndex]->audioFilePlayerCallBack.bPlaying;
	}

	bool xaudiolib::IsSePlaying(int bgmIndex)
	{
		if(!m_audioAvailable)
		{
			return false;
		}

		return m_soudSeDataList[bgmIndex]->audioFilePlayerCallBack.bPlaying;
	}

	bool xaudiolib::SuspendBgm()
	{
		if(!m_audioAvailable)
		{
			return false;
		}

		this->m_musicEngine->StopEngine();

		return true;
	}

	bool xaudiolib::ResumeBgm()
	{
		if(!m_audioAvailable)
		{
			return false;
		}

		this->m_musicEngine->StartEngine();

		return true;
	}

	bool xaudiolib::SetBgmVolume(int bgmIndex, float volume)
	{
		if(!m_audioAvailable || m_soudBgmDataList[bgmIndex] == nullptr)
		{
			return false;
		}

		m_soudBgmDataList[bgmIndex]->sourceVoice->SetVolume(volume);

		return true;
	}
	
	bool xaudiolib::GetBgmVolume(int bgmIndex, float *volume)
	{
		if(!m_audioAvailable || m_soudBgmDataList[bgmIndex] == nullptr)
		{
			return false;
		}

		m_soudBgmDataList[bgmIndex]->sourceVoice->GetVolume(volume);

		return true;
	}

	bool xaudiolib::SetSeVolume(int seIndex, float volume)
	{
		if(!m_audioAvailable)
		{
			return false;
		}

	}
	
	bool xaudiolib::GetSeVolume(int seIndex, float* volume)
	{
		if(!m_audioAvailable)
		{
			return false;
		}

	}


	/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


	AudioFilePlayerCallBack::AudioFilePlayerCallBack(Microsoft::WRL::ComPtr<IXAudio2> pXAudio2, Platform::String^ filename ,int soundIndex)
	{

		this->mfSourceReader = this->mediaReader.LoadMedia(filename);

		this->iSoundIndex = soundIndex;

		// Get the Media Foundation media type
		ComPtr<IMFMediaType> mfMediaType;
		HRESULT hresult = mfSourceReader->GetCurrentMediaType(MF_SOURCE_READER_FIRST_AUDIO_STREAM, &mfMediaType);

		if (FAILED(hresult))
			throw ref new COMException(hresult, "MFSourceReader->GetCurrentMediaType 取得に失敗");

		// Create a WAVEFORMATEX from the media type
		WAVEFORMATEX* pWaveFormat;
		unsigned int waveFormatLength;
		hresult = MFCreateWaveFormatExFromMFMediaType(mfMediaType.Get(), &pWaveFormat, &waveFormatLength);

		if (FAILED(hresult))
			throw ref new COMException(hresult, "MFCreateWaveFormatExFromMFMediaType 取得に失敗");

		// SoourceVoiceを作成
		hresult = pXAudio2->CreateSourceVoice(
			&pSourceVoice,
			pWaveFormat,
			XAUDIO2_VOICE_NOPITCH,
			1.0f,
			this);

		// WaveFomatを開放
		CoTaskMemFree(pWaveFormat);

		bPlaying = false;

	}

	void AudioFilePlayerCallBack::AudioFilePlayerEnd(int bgmIndex)
	{
		if(pSourceVoice!=nullptr)
		{
			this->IsStop();

			pSourceVoice->DestroyVoice();

			HRESULT hresult = MFShutdown();

			if (FAILED(hresult))
				throw ref new COMException(hresult, "MFShutdown failure");
		}
	}

	void AudioFilePlayerCallBack::SubmitBuffer()
	{
		// Get the next block of audio data
		int audioBufferLength;
		byte * pAudioBuffer = GetNextBlock(&audioBufferLength);

		if (pAudioBuffer != nullptr)
		{
			// Create an XAUDIO2_BUFFER for submitting audio data
			XAUDIO2_BUFFER buffer = {0};
			buffer.Flags = XAUDIO2_END_OF_STREAM;
			buffer.AudioBytes = audioBufferLength;
			buffer.pAudioData = pAudioBuffer;
			buffer.pContext = pAudioBuffer;
			HRESULT hresult = pSourceVoice->SubmitSourceBuffer(&buffer);

			if (FAILED(hresult))
				throw ref new COMException(hresult, "IXAudio2SourceVoice->SubmitSourceBuffer failure");
		}
	}

	void AudioFilePlayerCallBack::IsPlay(bool bLoop,int iSoundIndex)
	{
		this->bLoop = bLoop;
		this->soundIndex = iSoundIndex;

		// 停止処理
		this->IsStop();

		// 再生バッファ
		SubmitBuffer();
		SubmitBuffer();

		endOfFile = false;

		// 再生開始
		pSourceVoice->Start(0);

		bPlaying = true;
	}

	void AudioFilePlayerCallBack::IsStop()
	{
		bPlaying = false;

		pSourceVoice->Stop(0);
		pSourceVoice->FlushSourceBuffers();

		// 再生ポインタを先頭に
		this->ReStart();

	}

	void AudioFilePlayerCallBack::ReStart()
	{
		if (mfSourceReader == nullptr)
		{
			return;
		}

		PROPVARIANT var = {0};
		var.vt = VT_I8;

		DX::ThrowIfFailed(
			mfSourceReader->SetCurrentPosition(GUID_NULL, var)
			);
	}

	IXAudio2SourceVoice* AudioFilePlayerCallBack::GetSourceVoice()
	{
		return this->pSourceVoice;
	}

	byte * AudioFilePlayerCallBack::GetNextBlock(int * pAudioBufferLength)
	{
		// IMFSampleを取得
		ComPtr<IMFSample> mfSample;
		DWORD flags = 0;
		HRESULT hresult = mfSourceReader->ReadSample(MF_SOURCE_READER_FIRST_AUDIO_STREAM, 
			0, nullptr, &flags, nullptr, &mfSample);
		if (FAILED(hresult))
			throw ref new COMException(hresult, "MFSourceReader->ReadSample failure");

		// ファイルの終わりを確認する
		if (flags & MF_SOURCE_READERF_ENDOFSTREAM)
		{
			endOfFile = true;
			*pAudioBufferLength = 0;
			return nullptr;
		}

		// データをバッファへ
		ComPtr<IMFMediaBuffer> mfMediaBuffer;
		hresult = mfSample->ConvertToContiguousBuffer(&mfMediaBuffer);

		if (FAILED(hresult))
			throw ref new COMException(hresult, "IMFSample->ConvertToContiguousBuffer failure");

		// バッファが勝手に開放されないようにロックしておく
		uint8 * pAudioData = nullptr;
		DWORD audioDataLength = 0;
		hresult = mfMediaBuffer->Lock(&pAudioData, nullptr, &audioDataLength); 

		if (FAILED(hresult))
			throw ref new COMException(hresult, "IMFMediaBuffer->Lock failure");

		byte * pAudioBuffer = new byte[audioDataLength];
		CopyMemory(pAudioBuffer, pAudioData, audioDataLength);
		hresult = mfMediaBuffer->Unlock();

		if (FAILED(hresult))
			throw ref new COMException(hresult, "IMFMediaBuffer->Unlock failure");

		*pAudioBufferLength = audioDataLength;
		return pAudioBuffer;
	}

	// IXAudio2VoiceCallback バッファの終わりに呼び出される
	void _stdcall AudioFilePlayerCallBack::OnBufferEnd(void* pContext)
	{
		// Remember to free the audio buffer!
		delete[] pContext;

		// Either submit a new buffer or clean up
		if(bPlaying)
		{
			if (!endOfFile)
			{
				SubmitBuffer();
			}
			else
			{
				if(!bLoop)
				{
					this->IsStop();
				}
				else
				{
					this->ReStart();

					SubmitBuffer();
					SubmitBuffer();

					endOfFile = false;
				}
			}
		}
	}
};

まだ作り掛&未整理のため読みにくいですがご了承ください。
ファイルの読み込みにはマイクロソフトのサンプルに有った「MediaReader」に少々手を入れて使用しています。
「MediaReader」は転載禁止のため掲載できないため、MSのサンプルをご確認ください。

メモリ容量を意識しよう

WindowsストアアプリやWindowsPhoneアプリはガベージコレクション(GC)により、メモリ管理は比較的自動化され、あまり気にしなくてもよいようになっていますが、個人的にはGCにべったりではなく自分でメモリ容量を認識しながらアプリを作るべきではないかと思います。
GC管理されているからとメモリの使用量を気にかけずに開発すれば、それはメモリ不足などを引き起こし、アプリの停止や強制終了を起こします。

こういった現象を起こさないためにも、自身のコードやデータがどれだけのメモリを使用し、さらに使いそうなのか、どこでメモリの強制解放をすることでほかの部分に影響を与えずにメモリを適切に使うことができるかを見ていくべきでしょう。

必要ないデータは解放する、画像データやDBデータを必要な容量だけ使用するようにして、適時入れ替えるようにするなど単純なことですがこれらを意識してデータの最適化や、コードの最適化を図っていくようにしましょう。

何でこんなこと書いたかといえば、自分が作成したアプリでやらかしていたからです。
現象は解消して提出したので、問題なく公開されましたが、気が付いていなかったらリジェクトされた可能性または使用された方から指摘されたかなと思います。

たとえば、カメラを使用したアプリや画像を一覧表示するようなアプリの場合、保存用の大きな画像と一覧に表示する小さな画像をそれぞれ用意、生成しておき使い分けることでメモリの抑制になると思われます。

アプリ作成の際気にかけてみてはいかがでしょうか?

Windows8.1はタブレットの選択肢を増やすのか?

現在「Windows8.1 Preview」がMSから自己責任、正規版へのアップデート不能の条件で提供されています。※条件付きで更新可能でした m(_ _)m
正規版が出た際は「8.1 Preview」を入れていない場合は、アップデートインストール、入れている場合は、新規インストールを行うようになるようです。
提供はWindowsストアを経由してアップデートを提供するようですが、出てすぐ入れるよりは、動作確認を待って入れたほうがよいと思っています。

現状、開発者や動作検証向け専用で、一般の方が使用するのは進められないものですが、自分は仮想環境にインストールして少々動作を見てみました。

仮想環境下で動作が大幅に遅くなるかと思いましたが、思ったより快適に動作しています。
もちろんDirectXを使用したものは仮想環境なので厳しいですが、通常の操作ではストレスを感じるレベルではなく、正規版での動作を期待させるものでした。

Windows8.1はx86(x64)環境とARM環境(SurfaceRT等)双方に提供され、ARM環境用でビジネス向けにうれしいこととしてはOutlook 2013 RTの提供ではないでしょうか?
メールをPOP3受信が可能になるというのはビジネス上重要ではないかと思っています。
また、画面解像度が1024*768で小型(7インチ以下)の端末が解禁されたようで、縦持ち(ポートレート)を推奨する機種が出てきていることがタブレット分野への切込みとしては大きいと思っています。

Surface RT/PROは確かにいい端末だとは思いますが、大きさやその重さから他のiOSやAndroidのタブレットと比較された場合に分が悪いことがあります。
また、アプリのさらなる拡充が急がれるのではないかと思われ、特に日本では小型端末でのソーシャルゲームやSNS端末としての需要が大きく、今後国外でも小型端末と通常の大きさの物での使い分けが増えるのではないかと思います。

もちろん、現在日本では発売されていないWindowsPhone8との連携が整備されれば、さらに選択肢としては幅が広がり、デスクトップ、タブレット、スマートフォンすべてWindows環境での連携となることでしょう。

しかしながら、現状では「Iconia W3(x86)」くらいしか小型タブレットがなく、ARMの小型タブレットが出てきていません。
これはx86環境のアプリが使えたほうがいいという判断と、Windowsタブレットが盛り上がりに欠けているということなのかもしれません。

ただ、今後8.1がリリースされれば消費電力や動作の軽さがさらに改善されるのではないかと思われるので、x86、ARM双方の小型タブレットが出るのではないかと期待しており、タブレットの選択肢が増えていくのではないかと思っています。

※「Windows8.1 Preview」に関して、プレビュー版から正規版への更新は可能なようです。
 ただし、個人のドキュメント以外のアプリなどはすべて入れ直しが必要になるなどがあるようです。

ウェブフォントメモ

W3Cが規定したWOFF(Web Open Font Format)というのがあり、HTML5などではこれを使うようにしていく形で環境に縛られない形でFontを添付して使用するようにしていく模様。

Google Font
Google社が公開しているフォント類(使用条件などはそれぞれご確認ください)

Font Squirrel
フォントファイルとCSSなどを提供している
TTFをWOFFに変換する機能も提供しているが、すべてのフォントで行えるわけではなく、フォント作成者が拒否リストに登録している場合がある。

Nokia Imaging SDK

Nokia Imaging SDKというWinodwsPhone8用のフィルタ/エフェクトが公開されているようです。

さらっと流し読みですが、Nokia以外の端末でも使えるけど絶対使えるとは限らない、使う場合はCopyright表記を書くことという形のようです。

Nokia Lumia 1020が出たことでレンズ、カメラアプリが望まれるだろうからSDKで盛り上げてほしいという感じかな?

HTML5基本の覚書

<!DOCTYPE html>
<html lang="ja" class="no-js">
<head>
    <meta charset="UTF-8" />
    <title>html5基本</title>
    <!-- ブラウザ機能確認JS -->
    <script src="script/modernizr.js"></script>
    <!-- 高速CSSセレクタJS -->
    <script src="script/sizzle.js"></script>
    <!-- メイン用スタイルシートのリンク -->
    <link rel="stylesheet" href="styles/main.css" />
</head>

<body>
</body>
</html>

ここまでは定型文で使用可能
「!DOCTYPE html」でHTML5であることを宣言
「html lang=”ja”」使用言語の宣言、この場合は日本語で表記されていることを宣言している
「meta charset=”UTF-8″」使用している文字コードの宣言、UTF-8が一般的
「script src~」はJavaScriptの外部読み込み宣言
HTML5からType宣言(text/javascript)は必要なくなっている。

Modernizrを使用すると、ユーザーのブラウザで使用可能なHTML5、CSSの情報が取得できる
Modernizr HP
情報は、Modernizrを読み込むように指定しておくと「class=”no-js”」をIDとして情報が付加される。
ただし開発者ツールモードで見ないと見れないのでページソースを見るでは認識できない。

スタイルシートは「head」に記載する。
HTML5からType宣言(text/css)は必要なくなっている。

StreamSoketのSampleコード

非同期化していないところがあったりするのであまりいいサンプルではないですが、StreamSoketでの通信コードです。
WriteAsync、LoadAsyncで書き込み/読み込みを行うようにしてあります。
DataReader、DataWriterを使用した際にうまくいかなかったので、このような形で実装しています。

///////////////////////////////////////////////////////////////////////////////////////////////
// サーバへ接続等

        #region サーバへ接続
        /// <summary>
        /// TCPでサーバへ接続
        /// </summary>
        /// <param name="hostname"></param>
        /// <param name="serverport"></param>
        public async void TcpSocketConnect(string hostname, string serverport)
        {
            SocketStatusEventArgs socketevent = new SocketStatusEventArgs();

            // 接続済み
            if (SocketDatacontext.Connected)
            {
                socketevent.SocketStatus = StringResourceLoader.GetString("Already");
                OnSocketStatus(socketevent);
                cryearthlib.DebugLoging.DebugPrint(socketevent.SocketStatus);
                await Task.Run(() => { throw new PopClassException(SocketDatacontext.SocketMessage); });
                return;
            }

            if (SocketDatacontext.TcpSocket == null)
            {
                SocketDatacontext.TcpSocket = new Windows.Networking.Sockets.StreamSocket();

                bool currentSetting = SocketDatacontext.TcpSocket.Control.NoDelay;
                SocketDatacontext.TcpSocket.Control.KeepAlive = true;
                SocketDatacontext.TcpSocket.Control.NoDelay = false;
            }

            try
            {
                /// タイムアウト用
                CancellationTokenSource cts = new CancellationTokenSource();

                socketevent.SocketStatus = StringResourceLoader.GetString("Trying");

                OnSocketStatus(socketevent);

                cryearthlib.DebugLoging.DebugPrint(socketevent.SocketStatus); 
                
                var serverHost = new HostName(hostname);

                // タイムアウトの設定
                cts.CancelAfter(10000);

                await SocketDatacontext.TcpSocket.ConnectAsync(serverHost, serverport).AsTask(cts.Token);

                // DataReaderの作成
                SocketDatacontext.PeerReader = new DataReader(SocketDatacontext.TcpSocket.InputStream);
                SocketDatacontext.PeerReader.InputStreamOptions = InputStreamOptions.Partial;

                SocketDatacontext.Connected = true;
                SocketDatacontext.Closing = false;
                socketevent.SocketStatus = StringResourceLoader.GetString("Connection");
                OnSocketStatus(socketevent);
                cryearthlib.DebugLoging.DebugPrint(socketevent.SocketStatus);
            }
            catch (Exception ex)
            {
                socketevent.SocketStatus = StringResourceLoader.GetString("Connecterror") + ex.Message;
                OnSocketStatus(socketevent);

                SocketDatacontext.Closing = true;
                SocketDatacontext.TcpSocket.Dispose();
                SocketDatacontext.TcpSocket = null;
                SocketDatacontext.Connected = false;

                OnSocketStatus(socketevent);
                cryearthlib.DebugLoging.DebugPrint(socketevent.SocketStatus);
                throw new PopClassException(SocketDatacontext.SocketMessage);
            }
        }
        #endregion

///////////////////////////////////////////////////////////////////////////////////////////////
// サーバへデータを送る

        #region サーバへデータを送る
        public async void ResultSend(string req)
        {
            SocketStatusEventArgs socketevent = new SocketStatusEventArgs();

            if (!SocketDatacontext.Connected)
            {
                socketevent.SocketStatus = StringResourceLoader.GetString("Mustbeconnectedtosend");
                OnSocketStatus(socketevent);

                cryearthlib.DebugLoging.DebugPrint(socketevent.SocketStatus);
                return;
            }

            try
            {
                // サーバへリクエスト送信
                if (req != "")
                {
                    StreamSocketLib writeSokect = new StreamSocketLib();

                    socketevent.SocketStatus = StringResourceLoader.GetString("Tryingtosenddata");
                    OnSocketStatus(socketevent);

                    writeSokect.DataSend(SocketDatacontext.TcpSocket, req);

                    cryearthlib.DebugLoging.DebugPrint("Data Writer End");
                }
            }
            catch (Exception exception)
            {
                socketevent.SocketStatus = "Send data or receive failed with error: " + exception.Message;
                OnSocketStatus(socketevent);
            }
        }
        #endregion
        /// <summary>
        /// データ書き込みフロント
        /// </summary>
        /// <param name="socket"></param>
        /// <param name="senddata"></param>
        public void DataSend(StreamSocket socket, string req)
        {
            _socket = socket;

            Encoding encoding = Encoding.UTF8;

            byte[] bydata = encoding.GetBytes(req + Environment.NewLine);

            if (socket == null)
            {
                cryearthlib.DebugLoging.DebugPrint("socket Error : socket null");
                throw new Exception("socket Error : socket null");
            }

            try
            {
                var task = SocketDataWrite(bydata);
                if (!task.IsCompleted)
                {
                    var ret = task.Wait(timeout);
                    if (!ret)
                    {
                        cryearthlib.DebugLoging.DebugPrint("Write Time Out");
                    }
                }

                if (!task.Result)
                {
                    cryearthlib.DebugLoging.DebugPrint("Write Time Out");
                }
            }
            catch (Exception ex)
            {
                cryearthlib.DebugLoging.DebugPrint("DataWrite Error : " + ex.Message);
                throw new Exception("DataWrite Error : " + ex.Message);
            }
        }

        /// <summary>
        /// データ書き込み本体
        /// </summary>
        /// <param name="senddata"></param>
        /// <returns></returns>
        public async Task<bool> SocketDataWrite(byte[] senddata)
        {
            var writeTask = _socket.OutputStream.WriteAsync(senddata.AsBuffer()).AsTask();

            if (!writeTask.IsCompleted)
            {
                var writeret = writeTask.Wait(timeout);
                if (!writeret)
                {
                    return false;
                }
            }

            var flushTask = _socket.OutputStream.FlushAsync().AsTask();

            if (!flushTask.IsCompleted)
            {
                var flushret = flushTask.Wait(timeout);
                if (!flushret)
                {
                    return false;
                }
            }
            return true;
        }



///////////////////////////////////////////////////////////////////////////////////////////////
// サーバからのデータを読み込む

        #region サーバからのデータを読み込む
        public async Task<string> ResultRead()
        {
            SocketStatusEventArgs socketevent = new SocketStatusEventArgs();

            if (!SocketDatacontext.Connected)
            {
                socketevent.SocketStatus = StringResourceLoader.GetString("Mustbeconnectedtosend");
                OnSocketStatus(socketevent);

                return null;
            }

            try
            {
                var lastChar = string.Empty;
                var fullString = string.Empty;

                cryearthlib.Sleep(200);
                
                socketevent.SocketStatus = StringResourceLoader.GetString("Tryingtosenddata");
                OnSocketStatus(socketevent);

                CancellationTokenSource cts = new CancellationTokenSource(1000);
                cts.Token.ThrowIfCancellationRequested();
                var bytesRead = SocketDatacontext.PeerReader.LoadAsync(1024);

                Debug.WriteLine("StreamWriteAndRead : reader.LoadAsync : " + bytesRead.Status.ToString());

                if (bytesRead.Status != Windows.Foundation.AsyncStatus.Completed)
                {
                    cts.Cancel();

                    Debug.WriteLine("StreamWriteAndRead : cts.Cancel");
                    Debug.WriteLine("StreamWriteAndRead : " + bytesRead.Status.ToString());
                }
                else
                {
                    Debug.WriteLine("StreamWriteAndRead : ReadString : " + bytesRead.Status.ToString());

                    while (SocketDatacontext.PeerReader.UnconsumedBufferLength > 0)
                    {
                        fullString += SocketDatacontext.PeerReader.ReadString(SocketDatacontext.PeerReader.UnconsumedBufferLength);
                    }
                }

                SocketDatacontext.SocketMessage = socketevent.SocketStatus = fullString;
                OnSocketStatus(socketevent);

                cryearthlib.DebugLoging.DebugPrint(socketevent.SocketStatus);
                cryearthlib.DebugLoging.DebugPrint("reader.End");
                return fullString;
            }
            catch (Exception exception)
            {
                socketevent.SocketStatus = "Receive failed with error: " + exception.Message;
                OnSocketStatus(socketevent);
                cryearthlib.DebugLoging.DebugPrint(socketevent.SocketStatus);
                return socketevent.SocketStatus;
            }
        }
#endregion

Unity4.2が出てた

学習用に入れてたんですが、Unity4.2が出ていました。
大きな違いとしては「WindowsStoa」と「WindowsPhone8」向けのbuildが可能になったようです。

unity

buildの際に、専用のフォルダを作成して指定しないとbuildされないような気配です。

作製すると、VS2012用のソリューションファイルが作成されているので、VSで開き、WindowsPhone8実機に転送実行になります。

吐き出したUnityPlayerがARMのみのようなため実機(デバイス)での実行に制限されるようです。

ストアアプリ向けbuildを試したところ、エラーが発生して作成できませんでした。
エラーが文字化けしているため何でエラーなのかがちょっと不明ですが、ArrayList、Hashtableで起きています。
WP8用にbuildした際は通っているので、何かしらの制限かとも思うのですが不明です。

Unity勉強しないとな、、、