黒龍's Blog

新年のご挨拶

黒龍 — Wed, 02 Jan 2013 00:24:00 GMT

新年あけましておめでとうございます。昨年末はクリスマス前に風邪を引いて治りかけた頃にノロにかかるという残念な年末となりましたが年もあけて体調もすっかりよくなりました。去年はWindows PhoneとC#の基礎をまたしっかりやろうと思っていたのですが気がつけばObjective-Cの仕事が主になるという変化がありました。今年もあまり気負わず流れるがまま過ごしていきたいと思います。最後になりましたが本年もよろしくお願いします。

Linq for Objective-Cでお手軽シーケンス処理

黒龍 — Mon, 10 Dec 2012 15:00:00 GMT

Objective-C Advent Calendar 2012の12/11の記事です。

最近どの言語でもシーケンスに対する処理ライブラリが充実しています。Objective-Cにも列挙や列挙を行うための仕組みも用意されているので.netと同じようなアプローチでLinq的なメソッドを実装してみました。

Linqって？

.netが持っているコレクションに対する操作をSQLチックに書けるコンパイラサポートの事なんですがここではコレクションに対する一連の操作メソッドという広義のLinqの方を取り上げます。

で、何が出来るかというとシーケンスに対するフィルタや変換、処理適用なんかがループ的な構文を使用する事なく記述できます。

例としてあるNSArrayからNSStringのものだけをNSArrayにするケースを考えてみます。

まぁ普通に考えると列挙して新しい配列に足し込んでってのが思いつきます。こんな感じに

    NSMutableArray *stringArray = [[NSMutableArray alloc]init];
    NSMutableArray *result = [[NSMutableArray alloc]init];
    for (id obj in [stringArray objectEnumerator]) {
        if ([obj isKindOfClass:[NSString class]]) {
            [result addObject:obj];
        }
    }
    return [NSArray arrayWithArray:result];

特に難しい事もないと思います。で、これをここで公開しているLinq for Objective-C(以下Linq)で書くとこんな感じ

     return [[[stringArray objectEnumerator]ofClass:[NSString class]]toArray];

ずいぶんとすっきりしたと思います。

他にもフィルタをかけるwhere、変換を行うselectなんかがあります。ありそうな例としてNSDictionaryとして受信したjsonがあったとします。それをフィルタをかけながら独自型に変換するようなイメージで書くと…

   NSArray *shops = [json objectForKey:@"shops"];
    return [[[shops objectEnumerator]
             select:^id(id shop) {
                 NSDictionary *shopDic = shop;
                 ShopData *result = [[ShopData alloc]init];
                 result.id = [json objectForKey:@"id"];
                 result.name = [json objectForKey:@"name"];
                 result.genre = [json objectForKey:@"genre"];
                 result.coordinate = CLLocationCoordinate2DMake([[json objectForKey:@"latitude"] doubleValue], [[json objectForKey:@"longitude"] doubleValue]);
                 result.image_url = [json objectForKey:@"image_url"];
                 return result;
             }]where:^BOOL(id item) {
                 return [(ShopData *)shop.genre isEqual:@"イタリアン"];
             }]toArray];

こんな感じになります。

まぁほとんど変換の部分が冗長なのでinitWithJSON:(NSDictionary*)json見たいなメソッドを作ってやればすっきりすると思います。

他にもいろいろなメソッドの組み合わせでフィルタをかける事が出来ますが冗長になってしまう場合や処理を自分で書きたい場合はCustomEnumeratorという列挙処理のヘルパがありますので処理をブロックで渡す事で独自の列挙処理を行う事が出来ます。

改行コードで一行ずつ取り出す例。マルチパートヘッダなど一気にNSStringに出来ないようなケースもあると思います。その場合はNSDataを直で列挙するobjectEnumeratorもカテゴリで追加しているのでcharでの処理も可能です。

- (NSEnumerator *)headers:(NSEnumerator *)src {
    return [[CustomEnumerator alloc]initWithFunction:src nextObjectBlock:^id(NSEnumerator *_src) {
        NSData * headData = [[_src takeWhile:^BOOL(id charNum) {
            
            char charByte = [( NSNumber*)charNum charValue];
            return (charByte != '\r');
        }]
                             toData];
        //最後まで読んでいるかチェックする。
        if ([[_src take:1]singleOrNil] == nil){
            //改行なく最後まで読んでいる場合は今回の解析は見送る。
            //バッファに今のデータを追加する。
            bufferData = [[NSMutableData alloc]initWithData:headData];
            return nil;
        }
        return [[NSString alloc]initWithData:headData encoding:NSUTF8StringEncoding];
    }];   
}

これらの処理メソッドですがもう一つの特徴として遅延処理があげられます。どういう事かというとフィルタや選択の各種メソッドは呼んだだけでは処理が登録されるのみで最終的にforinで列挙する際やtoXXXメソッドで変換する際に処理される事になります。

(toArray、toMutableArray、toDictionary、toMutableDictionary、toData、toStringなどいろいろな処理があります)

なので通常こういった処理を分割した際にありがちなバッファのコピーが余計に発生する事はないためメモリには優しい処理となる可能性もあります。色々とメソッドがあってややこしいですがネットでもいろんな言語でシーケンス処理の例はありますのでそれらの処理をうまくObjective-Cに持って来れると思います。

また、ちょっとしたループ処理でも書けばバグの可能性は出てくるのでやりたい処理に注力できるこういったシーケンス処理ライブラリをぜひ使ってみませんか？（と、宣伝で締めてみる）

それでわ～

Linq for Objective-C

黒龍 — Sun, 18 Nov 2012 02:01:00 GMT

ここのところWindowsから離れてiPhoneアプリ開発をやってます。言語の違いも大きいのですがやっぱり慣れた構文で書きたいのでブロック構文のカテゴリとかもりもり作ってます。で、そんな過程でObjective-CにLinqがないのがどうにも我慢できなかったので作ってみました。

Windows phone archでちらっと話してみたら意外と食いつきがよかったので晒しておきます。

RyujiSamejima/Linq ・ GitHub

匿名型がないとかジェネリックがないとか型推論がないとかで構文的にはどうしても冗長になっちゃいますが同じノウハウが使えるのは割といい感じです。

NSMutableArray *shops = [[completedOperation.responseJSON objectForKey:@"results"]objectForKey:@"shop"];
NSMutableArray *shopList = [[[shops objectEnumerator]
                                      select:^id(id shop)
                                      {
                                          NSDictionary * shopDic = shop;
                                          return [shopData shopInitWithJson:shopDic];
                                      }]
                                     toArray];

Objective-Cを触らざるをえないLinq星人な人にはお勧めです。

ReactiveOAuthでお手軽ツイッター連携アプリ

黒龍 — Sat, 07 Apr 2012 18:43:00 GMT

いまどきはHello WorldならぬツイッターのTL表示がサンプルとしてよく見かけるように思います。お勉強の題材でも色々触っててふと思ったのですがStreamingのある今って@に反応するようなBotがタイムラグなしに実現できるんじゃなかろうか？と。というわけでやってみました。

まずは認証のための登録をhttp://twitter.com/appsで済ませておきます。（作るアプリのタイプによっては不要です）

で認証部分ですがReactiveOAuthを使わせていただきました。（@neueさん感謝です）

まぁゴテゴテかいてもあれなのでソースをば

static void Main(string[] args)
{
    var client = new OAuthClient(consumerKey, consumerSecret, accessToken)
    {
        Url = "https://userstream.twitter.com/2/user.json"
    };
    var us = client.GetResponseLines()
        .Where(s => !string.IsNullOrWhiteSpace(s)) // filter invalid data
        .Select(s => // 文字列JSONからXElementへ変換
            {
                using (var jsonReader = JsonReaderWriterFactory.CreateJsonReader(Encoding.Default.GetBytes(s), XmlDictionaryReaderQuotas.Max))
                    return XElement.Load(jsonReader);
            })
        .Where(d => d.Element("entities") != null 
            && d.Element("entities").Elements("user_mentions").Count(_ => _.Element("item") != null && _.Element("item").Element("screen_name").Value == "LinqFe") > 0)
        //.ObserveOnDispatcher()
        .Subscribe(
            d => ParseAndAction(d),
            ex => Console.Error.WriteLine(ReadWebException(ex)));

    Console.ReadKey();
    us.Dispose();
}

使い方のサンプルそのままな感じですが一応開設するとLinqTojson（JsonReaderWriterFactory経由によるLinqToXML）な感じで読み取ってWhereのところでLinqFe宛のツイートをフィルタリングして中身を処理するParseAndAction()にXMLを渡す。ただそれだけです。

Whereの中身がうるさい感じですがこういったWebのものはデシリアライズしてクラスに起しちゃうよりXMLで文字列で読み取ってるのが正解。。とおもいます。無関係な定義の変更なんかに煩わされずに済むので。いるとこだけ定義したクラスへのデシリアライズでもいいんですがさっと思いついた機能をさっと足すぐらいのほうが楽でいいです。

で、作ってみたのがこちら。おうむ返しのBotでもいいんですがこないだからいじってたHotPepperからの検索をしてくれるBotにしてみました。実行結果はこちらになります。

ReactiveOAuth、Rxのお手軽さとStreaming APIの強力さがよくわかる題材でした。こういったエージェントっぽい反応をするBotは以前はラグがあっていまいちだったんですが今はStreamingでリアルタイムに反応できるので面白いと思います。

RXでのキャンセル

黒龍 — Wed, 08 Feb 2012 00:49:00 GMT

大事なことなのに放置してたのでエントリ。Rxでのいいところの一つにDisposeでのキャンセルがあると思います。とはいえ私もあまり詳しくないのでメモ代わりですがRxなクエリの最終段階の購読登録であるSubscribeメソッドですが戻りがIDisposableになってます。で、こいつのDisposeを呼ぶことでイベントハンドラから外れて以後のイベントは飛んでこなくなります。だいたい非同期にしたいからRx使うんで遅い(or その他)理由でキャンセルしたいケースがかなりあるかと思います。そんな時にDisposeってことで以前のコードにつけてみました。

で試してみるとおぉ～止まる。また取得して～おぉ～止まる。でもってまた取得して～～～？ん？取得しない？？

なんか固まってるっぽい。てかこの挙動HTTPの通信上限っぽい動き^^;

イベントハンドラからは外れているもののそもそもの受信待ちの取得ができなくなってDisposeされてない感じに思えます。んむむ。。。どうやればいいのかさっぱりわからん。色々調べていくといろんなやり方がありそうだけどもneueさんところにあったWebRequestをAbortするパターンってのが良さげでした。ただソースが追いにくい。。。Rxの習熟度が低い私からみるとまるで魔法のようなコード。ちょっとしっかり覚えなきゃだなぁ。

marshal_as<const char*>はThread.Current.Cultureの影響を受ける

黒龍 — Tue, 07 Feb 2012 22:58:00 GMT

知ってる人からしたら当たり前なのかもですが不思議に思ったのでメモ。

C++/CLIですがアンマネージとの変換はいろいろ手法があります。まぁ文字列型もいろいろあるのでその辺は仕方ないんですが割と低レベルというかCレベルのものと組み合わせる時はconst char*になると思います。で、このconst char*とのやり取りですが.net からであればIntPtr ptr = Marshal::StringToHGlobalAnsi(text); あたりがメジャーかと思います。Marshal::FreeHGlobal(ptr);さえ忘れなければよくあるAnsi（sjis）な文字列との変換はオッケー。

で、タイトルに書いたmarshal_as<>ですがこいつも2008から入ってきたのと他の変換と同じに書けるのもあってモリモリ使ってました。が、こいつですが内部でWideCharToMultiByteを使っていることもあって現在のThreadのコードページの影響をうけます。どういうことかというとSystem:String^な文字列をSJISにしたいなぁって時にふつうのアプリからなら問題ないです。が、ローカライズで英語リソース読むようにCultureを変更するような場合だとSJISじゃなくてコードページ1252みたいなことになっちゃいます。

確かにローカライズで扱う文字も変わるとはいえアプリの本質も通信する先もSJISなのは変わらないので余計なお世話かなぁと感じた次第です。なのでSJISな奴との通信がある場合の変換はmarshal_asじゃなくStringToHGlobalAnsiあたりを使っとくほうが間違いがないと思います。上記挙動って覚えてればいいですがすっかり忘れる気がするので。

以上。あまり役に立たないかもな情報でした。

JSONに苦しむの巻

黒龍 — Mon, 30 Jan 2012 23:13:00 GMT

しつこくも続いてます。

やっぱりJOSNのほうがデータ小さいしJSON対応にすっかーと思ってJsonReaderWriterFactoryを挟んでみたらあっさりと成功。いわゆるLinq to JSONってやつですな。気をよくしてSLとWP7もやりますかね～って感じで書き換えていったまではいいのですが。。。

ない。。。

WP7にJsonReaderWriterFactoryがねェ！！まじかよ～と嘆きつつもないものは仕方ないのでDataContractJsonSerializerでシリアライズする方向に。JsonReaderWriterFactoryは幸せなんですがマルチな展開を考えるとDataContractJsonSerializer一択って感じですね。。。とはいえWeb相手だとガッツリ定義できないことも多いのでなかなか悩ましい。。。とはいえDataContractJsonSerializer自体はかなりいい感じです。さっくりとデシリアライズできたのでなにも困らなかったです。JsonReaderWriterFactoryを使ってのLinqToJSONはT4とかで生かすといい感じになるんじゃないでしょうか。

今回とくに書くネタもないんですが検索部分を若干修正しました。複数回指定できるようなパラメータがあるんですが今までパラメータをWhere句から拾ってDictionaryに突っ込んでたので同一のキーが定義できなかったのでList<KeyValuePair<string, string>>な感じに変えるとともにドメイン（定義域）を持ったやつをクラスにくくり出しました。まぁふつうはEnumにするところなんですが最終的な文字列への落とし込みとExpressionからの拾い上げがめんどいのでEnumじゃないです。どういうものかというと。。。

/// <summary>
/// 検索範囲
/// </summary>
public struct Range
{
    private string _value;
    internal string Value { get { return _value; } }
    public static Range m300 { get { return new Range("1"); } }
    public static Range m500 { get { return new Range("2"); } }
    public static Range km1 { get { return new Range("3"); } }
    public static Range km2 { get { return new Range("4"); } }
    public static Range km3 { get { return new Range("5"); } }
    private Range(string value) 
    {
        this._value = value;
    }
    public override string ToString()
    {
        return _value;
    }
    public static bool operator ==(Range lhs, Range rhs)
    {
        return lhs.Value == rhs.Value;
    }
    public static bool operator !=(Range lhs, Range rhs)
    {
        return !(lhs == rhs);
    }
}

こんな感じで文字列Enumっぽいものとしてよく作られるんじゃないかなぁと想像。こうすると文字列だと間違うところが間違えないし比較対象も限定できるので。（EqualsとかGetHashはいらないので手抜き^^;）

実際動かしてみるとRxのメリットはかなり大きいですね。何より止まらずにデータが振ってくるのはかなり素敵な感じです。

さぁ。準備はできたのでSilverlightのお勉強ができるぞっと。

LinqTo? そしてRXへ…

黒龍 — Sat, 21 Jan 2012 18:57:00 GMT

前回まででおよその形は出来上がりました。まぁいまどきのアプリってSilverlightとかだわなぁってことでSL、WP7から使えるようにライブラリをこさえてみようと思ったんですがうまくいかない。

WebClientで同期でとっちゃってるんでそりゃ駄目だわな。非同期に書き換えるとして。。。IEnumerableで返せん。。。Linq構文あきらめてただのWebClientの非同期サンプルにする？それは負けだろう。

…Rxだな。。。

とはいえRXで非同期をなんてサンプルはどこにでもある話。やるなら噂で聞いたIQbservableかなぁと漠然と思いながらneueさんのRxのライブラリ紹介とかを見ながらお勉強。どうせなら同じソースで動かしたいよねぇってことでRxを落としてくる。が、ここで問題発生。どうもWP7にはIQbservableがなさそうな予感。。。色々悩んだ結果以前の部分でIEnumerableを返してたのでTの部分を非同期リクエストの戻りであるIObservableを内包した形で返すことに。合わせてResult周りの型を変更。GourmetResult : ResultBase>な感じに。

ではプロジェクトのほうを整えることに。Coreに切りだしていた部分はそのまま使うのでリンクで追加。あ、そうそうWP7にはExpressionVisitorがないんですがMSDNのサイトにソースが全部あるので追加。プロバイダ周りは書き換えるのでコピーで追加しました。全体像してはこんな感じ。

PagingQueryProviderを書き換えていくことにします。肝としてはWebClientで動機リクエストしてたところをIObservable化するところってことですが@ITにずばりな感じの入門記事があったのでそれを参考に。

第1回　Reactive Extensionsの概要と利用方法

WebClientにDownloadStringAsyncってのが追加されてIObservableで返ってきますのでその後パースしてってところは前と同じ。

var req = WebRequest.Create(executeUrl);

var o = req.DownloadStringAsync().Select(_ =>
    {
        var element = XDocument.Parse(_);
        var ns = element.Root.GetDefaultNamespace();

        //エラーチェック
        var error = element.Descendants(ns + "error").FirstOrDefault();
        if (error != null) throw new InvalidQueryException(new Error(ns, error).Message);

        //クエリー条件にマッチする、検索結果の全件数
        this.limit = int.Parse(element.Descendants(ns + "results_available").FirstOrDefault().Value);
        //このＸＭＬに含まれる検索結果の件数クエリー条件にマッチする、検索結果の全件数
        this.returnedCount = int.Parse(element.Descendants(ns + "results_returned").FirstOrDefault().Value);
        //検索結果の開始位置
        var resultStart = int.Parse(element.Descendants(ns + "results_start").FirstOrDefault().Value);

        var collection = element.Descendants(ns + name);

        //取得件数が指定されているなら補正する
        if (takeCount.HasValue)
        {
            var endLimit = takeCount.Value + start;
            this.limit = Math.Min(endLimit, this.limit);
        }
        return collection.Select(x => innerBuilder(x)).ToArray();
    });

こんな感じです。パース後にDescendantsするとXElement[]になるんですが途中部分でサクッと変換はやりにくいので要素一個のファクトリメソッドを受け取るようにしておきました。（FuncなinnnerBuilderってやつです）これでIObservableって形になるのでこれを前回の結果のIEnumerableを内包した結果で返します。

継続部分をとる必要がありますが以前はIEnumerableだったので普通にConcatでした。今回はIObservableとIEnumerable>をつないで返すことに。これはEnumerable.Repeat(o, 1).Concat(GetResultCore(url))でおけ。

でとりだしの部分ですがIObservableとIEnumerable、配列が混在なのでちょっとややこしいですが分けて考えれば大丈夫。

var context = new HotpepperContext();
var query = (
    from result in context.Gourmet
    where result.keyword == this.textBox1.Text
    select result).Take(100).First().Results.Concat();

var subscribe = (
    from results in query
    from shop in results
    select shop)
    .ObserveOnDispatcher()
    .Subscribe(_ =>
        {
            count++;
            this.textBlock1.Text = count.ToString();
            this.listBox1.Items.Add(_);
        });

こうなります。前半は以前と同様IQeryableを使ってるところ。IEnumerableを含んだ（Resultsがそれ）結果がひとつ返るのでFirstしてResultsをConcat。この操作でIEnumerable>がIObservableに平滑化されます。このまま続けて書いてもいいのですがここまではIQueryable、これからはIObservableという違いとT[]で返るのでSelectManyがわかりやすいように分けてクエリ構文で記載してみました。

感触ですがかなり簡単に取れるのでいい感じ。もろもろまとめて公開予定ですがひとまずPageQueryProviderのソースだけでも乗っけときますね。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;
using System.Xml.Linq;
using System.Xml;
using System.Net;
using System.Reactive.Linq;
using System.IO;

namespace LinqToHotpepper
{
    /// 
    /// ファクトリクラス
    /// 
    public static class PagingQueryProvider
    {
        /// 
        /// ファクトリメソッド
        /// 
        /// 発行されたAPIキー
        /// リクエストURL
        /// 抽出対象のXML要素名
        /// 結果セットのファクトリ
        /// 結果のファクトリ
        public static PagingQueryProvider Create(string apiKey, string baseUrl, string name, Func<IEnumerable<IObservable>, T1> builder, Func<XElement, T2> innerBuilder)
        {
            return new PagingQueryProvider(apiKey, baseUrl, name, builder, innerBuilder, null);
        }
        /// 
        /// ファクトリメソッド
        /// 
        /// 発行されたAPIキー
        /// リクエストURL
        /// 抽出対象のXML要素名
        /// 結果のファクトリ
        /// 結果セットのファクトリ
        /// 要素から抽出を行うFinder
        public static PagingQueryProvider Create(string apiKey, string baseUrl, string name, Func<IEnumerable<IObservable>, T1> builder, Func<XElement, T2> innerBuilder, EqualsFinder finder)
        {
            return new PagingQueryProvider(apiKey, baseUrl, name, builder, innerBuilder, finder);
        }
    }
    public class PagingQueryProvider : QueryProviderBase
    {
        /// 発行されたAPIキー
        private string key;
        /// リクエストURL
        private string baseUrl;
        /// 要素から抽出を行うFinder
        private EqualsFinder finder;
        /// 抽出対象のXML要素名
        private string name;
        /// 結果セットのファクトリ
        private Func<IEnumerable<IObservable>, T1> resultBuilder;
        /// 結果セットのファクトリ
        private Func<XElement, T2> innerBuilder;
        /// 開始件数
        private int start;
        /// 取得中件数
        private int index;
        /// 取得終了件数
        private int limit;
        /// 取得時の戻り件数（初回リクエスト時の戻り件数）
        private int returnedCount;
        /// パラメータで指定された取得件数
        private int? takeCount;
        /// デフォルトの取得件数
        private const int DEFAULT_COUNT = 30;

        /// 
        /// コンストラクタ
        /// 
        /// 発行されたAPIキー
        /// リクエストURL
        /// 抽出対象のXML要素名
        /// 結果のファクトリ
        /// 要素から抽出を行うFinder
        public PagingQueryProvider(string apiKey, string baseUrl, string name, Func<IEnumerable<IObservable>, T1> builder, Func<XElement, T2> innerBuilder, EqualsFinder finder)
        {
            this.start = 0;
            this.key = apiKey;
            this.baseUrl = baseUrl;
            this.name = name;
            this.resultBuilder = builder;
            this.innerBuilder = innerBuilder;
            this.finder = finder;
        }

        protected override IEnumerable GetResult(Expression expression)
        {
            InnermostFinder innerFinder = new InnermostFinder();
            var sb = new StringBuilder(baseUrl);
            sb.AppendFormat("?key={0}", key);
            if (finder != null)
            {
                MethodCallExpression whereExpression = innerFinder.GetInnermostWhere(expression);
                if (whereExpression != null)
                {
                    LambdaExpression lambdaExpression = (LambdaExpression)((UnaryExpression)(whereExpression.Arguments[1])).Operand;
                    // Send the lambda expression through the partial evaluator.
                    lambdaExpression = (LambdaExpression)Evaluator.PartialEval(lambdaExpression);
                    finder.Expression = lambdaExpression.Body;

                    foreach (var item in finder.Results)
                    {
                        sb.AppendFormat("&{0}={1}", item.Key, item.Value);
                    }
                }
            }

            MethodCallExpression skipExpression = innerFinder.GetInnermostSkip(expression);
            if (skipExpression != null)
            {
                this.start = int.Parse(ExpressionTreeHelpers.GetValueFromExpression(skipExpression.Arguments[1]));
            }

            MethodCallExpression takeExpression = innerFinder.GetInnermostTake(expression);
            if (takeExpression != null)
            {
                this.takeCount = int.Parse(ExpressionTreeHelpers.GetValueFromExpression(takeExpression.Arguments[1]));
            }

            var url = sb.ToString();

            var executeUrl =  string.Format("{0}&start={1}",url, start + 1);

            if (takeCount.HasValue) executeUrl = string.Format("{0}&count={1}", executeUrl, takeCount.Value);

            var req = WebRequest.Create(executeUrl);

            var o = req.DownloadStringAsync().Select(_ =>
                {
                    var element = XDocument.Parse(_);
                    var ns = element.Root.GetDefaultNamespace();

                    //エラーチェック
                    var error = element.Descendants(ns + "error").FirstOrDefault();
                    if (error != null) throw new InvalidQueryException(new Error(ns, error).Message);

                    //クエリー条件にマッチする、検索結果の全件数
                    this.limit = int.Parse(element.Descendants(ns + "results_available").FirstOrDefault().Value);
                    //このＸＭＬに含まれる検索結果の件数クエリー条件にマッチする、検索結果の全件数
                    this.returnedCount = int.Parse(element.Descendants(ns + "results_returned").FirstOrDefault().Value);
                    //検索結果の開始位置
                    var resultStart = int.Parse(element.Descendants(ns + "results_start").FirstOrDefault().Value);

                    var collection = element.Descendants(ns + name);

                    //取得件数が指定されているなら補正する
                    if (takeCount.HasValue)
                    {
                        var endLimit = takeCount.Value + start;
                        this.limit = Math.Min(endLimit, this.limit);
                    }
                    return collection.Select(x => innerBuilder(x)).ToArray();
                });
            yield return resultBuilder(Enumerable.Repeat(o, 1).Concat(GetResultCore(url)));
        }
        /// 
        /// 繰り返し部分の取得実体
        /// 
        /// 
        /// 
        private IEnumerable<IObservable> GetResultCore(string url)
        {
            //次回取得位置を初期化
            index = start + returnedCount;
            //取得ループ開始
            while (true)
            {
                //欲しい件数が取れているなら終了
                if (limit < index + 1) yield break;
                var executeUrl = string.Format("{0}&start={1}", url, start + 1);

                //残りカウントを取得
                var leftCount = limit - (index + returnedCount);
                //取得件数より小さければ取得件数を減らす
                if (leftCount < returnedCount) executeUrl = string.Format("{0}&count={1}", executeUrl, leftCount);

                var req = WebRequest.Create(executeUrl);

                var o = req.DownloadStringAsync().Select(_ =>
                    {
                        var element = XDocument.Parse(_);
                        var ns = element.Root.GetDefaultNamespace();

                        //エラーチェック
                        var error = element.Descendants(ns + "error").FirstOrDefault();
                        if (error != null) throw new InvalidQueryException(new Error(ns, error).Message);

                        //クエリー条件にマッチする、検索結果の全件数
                        var total = element.Descendants(ns + "results_available").FirstOrDefault();
                        // このＸＭＬに含まれる検索結果の件数クエリー条件にマッチする、検索結果の全件数
                        var returned = element.Descendants(ns + "results_returned").FirstOrDefault();
                        //結果がなければ終了
                        if (total == null || total.Value == "0" || returned == null || returned.Value == "0") Observable.Empty<XElement[]>();

                        var collection = element.Descendants(ns + name);

                        index += int.Parse(returned.Value);

                        return collection.Select(x => innerBuilder(x)).ToArray();
                    });
                yield return o;
            }
        }
    }
}

public static class WebRequestExtensions
{
    public static IObservable<string> DownloadStringAsync(this WebRequest request)
    {
        return Observable.Defer(() => Observable.FromAsyncPattern<WebResponse>(
                request.BeginGetResponse, request.EndGetResponse)()
            .Select(res =>
            {
                using (var stream = res.GetResponseStream())
                using (var sr = new StreamReader(stream))
                {
                    return sr.ReadToEnd();
                }
            }));
    }
}

コーディング量はそうないもののいい感じにWP7対応できました。

※ひとまず今までの一式。WP7位置情報とか簡単に取れて面白いかも。

Linq to いろいろその４。ページング対応部分を整えてLinqToHotpepperを完成させる

黒龍 — Tue, 10 Jan 2012 01:37:00 GMT

前回（Linq to 色々その３．汎用的な呼び出しのベースを作成する。）、ひとまずクエリを投げて取得する汎用的なものは作成できました。今回はページング対応のものを完成させることにします。ページングで汎用的なものを作ればグルメサーチも店名サーチも両方使えますね！

今回ページングするにあたってSkipとTakeは必要そうなのでInnermostWhereFinderをInnermostFinderとリネームして中身にSkip、Takeの取得を追加します。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace LinqToHotpepper
{
    internal class InnermostFinder : ExpressionVisitor
    {
        private MethodCallExpression innermostWhereExpression;
        private MethodCallExpression innermostSkipExpression;
        private MethodCallExpression innermostTakeExpression;

        public MethodCallExpression GetInnermostWhere(Expression expression)
        {
            Visit(expression);
            return innermostWhereExpression;
        }

        public MethodCallExpression GetInnermostSkip(Expression expression)
        {
            Visit(expression);
            return innermostSkipExpression;
        }
        public MethodCallExpression GetInnermostTake(Expression expression)
        {
            Visit(expression);
            return innermostTakeExpression;
        }
        protected override Expression VisitMethodCall(MethodCallExpression expression)
        {
            if (expression.Method.Name == "Where")
                innermostWhereExpression = expression;

            if (expression.Method.Name == "Skip")
                innermostSkipExpression = expression;
            
            if (expression.Method.Name == "Take")
                innermostTakeExpression = expression;

            Visit(expression.Arguments[0]);
            return expression;
        }
    }
}

Modifierも併せて修正。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace LinqToHotpepper
{
    public static class ExpressionTreeModifier
    {
        public static ExpressionTreeModifier<T> Create<T>(IQueryable<T> query)
        {
            return new ExpressionTreeModifier<T>(query);
        }
    }
    public class ExpressionTreeModifier<T> : ExpressionVisitor
    {
        private IQueryable<T> queryable;

        internal ExpressionTreeModifier(IQueryable<T> query)
        {
            this.queryable = query;
        }

        protected override Expression VisitMethodCall(MethodCallExpression node)
        {
            if (node.Method.Name == "Where")
                return Visit(node.Arguments[0]);

            if (node.Method.Name == "Skip")
                return Visit(node.Arguments[0]);
            
            if (node.Method.Name == "Take")
                return Visit(node.Arguments[0]);
            
            return base.VisitMethodCall(node);
        }

        protected override Expression VisitConstant(ConstantExpression c)
        {
            // Replace the constant Query<T> arg with the queryable Place collection.
            if (c.Type == typeof(Query<T>))
                return Expression.Constant(this.queryable);
            else
                return c;
        }
    }
}

Whereとおんなじ感じで追加。で、Whereの抽出部分を以前はQueryProviderBase<T>の中でやってたんですがSkipはページングしない場合は必要ないのでWhereの解釈部分も派生クラス側でやるように修正。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;

namespace LinqToHotpepper
{
    public abstract class QueryProviderBase<T> : IQueryProvider
    {
        public IQueryable CreateQuery(Expression expression)
        {
            Type elementType = TypeSystem.GetElementType(expression.Type);
            try
            {
                return (IQueryable)Activator.CreateInstance(typeof(Query<>).MakeGenericType(elementType), new object[] { this, expression });
            }
            catch (System.Reflection.TargetInvocationException tie)
            {
                throw tie.InnerException;
            }
        }

        // Queryable's collection-returning standard query operators call this method.
        public IQueryable<TResult> CreateQuery<TResult>(Expression expression)
        {
            return new Query<TResult>(this, expression);
        }

        public object Execute(Expression expression)
        {
            return this.Execute<object>(expression, false);
        }

        // Queryable's "single value" standard query operators call this method.
        // It is also called from QueryableGourmetData.GetEnumerator().
        public TResult Execute<TResult>(Expression expression)
        {
            bool IsEnumerable = (typeof(TResult).Name == "IEnumerable`1");

            return this.Execute<TResult>(expression, IsEnumerable);
        }

        public TResult Execute<TResult>(Expression expression, bool IsEnumerable)
        {
            // The expression must represent a query over the data source.
            if (!IsQueryOverDataSource(expression))
                throw new InvalidProgramException("No query over the data source was specified.");

            IQueryable<T> result = GetResult(expression).AsQueryable<T>();

            var treeCopier = ExpressionTreeModifier.Create(result);
            Expression newExpressionTree = treeCopier.Visit(expression);

            // This step creates an IQueryable that executes by replacing Queryable methods with Enumerable methods.
            if (IsEnumerable)
                return (TResult)result.Provider.CreateQuery(newExpressionTree);
            else
                return (TResult)result.Provider.Execute(newExpressionTree);
        }

        private bool IsQueryOverDataSource(Expression expression)
        {
            // If expression represents an unqueried IQueryable data source instance,
            // expression is of type ConstantExpression, not MethodCallExpression.
            return (expression is MethodCallExpression);
        }

        protected abstract IEnumerable<T> GetResult(Expression expression);
    }
}

あとはページング対応のProviderを実装。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;
using System.Xml.Linq;
using System.Xml;
using System.Net;

namespace LinqToHotpepper
{
    /// <summary>
    /// ファクトリクラス
    /// </summary>
    public static class PagingQueryProvider
    {
        /// <summary>
        /// ファクトリメソッド
        /// </summary>
        /// <param name="apiKey">発行されたAPIキー</param>
        /// <param name="baseUrl">リクエストURL</param>
        /// <param name="name">抽出対象のXML要素名</param>
        /// <param name="builder">結果のファクトリ</param>
        public static PagingQueryProvider<T> Create<T>(string apiKey, string baseUrl, string name, Func<IEnumerable<XElement>, T> builder)
        {
            return new PagingQueryProvider<T>(apiKey, baseUrl, name, builder, null);
        }
        /// <summary>
        /// ファクトリメソッド
        /// </summary>
        /// <param name="apiKey">発行されたAPIキー</param>
        /// <param name="baseUrl">リクエストURL</param>
        /// <param name="name">抽出対象のXML要素名</param>
        /// <param name="builder">結果のファクトリ</param>
        /// <param name="finder">要素から抽出を行うFinder</param>
        public static PagingQueryProvider<T> Create<T>(string apiKey, string baseUrl, string name, Func<IEnumerable<XElement>, T> builder, EqualsFinder<T> finder)
        {
            return new PagingQueryProvider<T>(apiKey, baseUrl, name, builder, finder);
        }
    }
    public class PagingQueryProvider<T> : QueryProviderBase<T>
    {
        /// <summary>発行されたAPIキー</summary>
        private string key;
        /// <summary>リクエストURL</summary>
        private string baseUrl;
        /// <summary>要素から抽出を行うFinder</summary>
        private EqualsFinder<T> finder;
        /// <summary>抽出対象のXML要素名</summary>
        private string name;
        /// <summary>結果セットのファクトリ</summary>
        private Func<IEnumerable<XElement>, T> resultBuilder;
        /// <summary>開始件数</summary>
        private int start;
        /// <summary>取得中件数</summary>
        private int index;
        /// <summary>パラメータで指定された取得件数</summary>
        private int? takeCount;

        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="apiKey">発行されたAPIキー</param>
        /// <param name="baseUrl">リクエストURL</param>
        /// <param name="name">抽出対象のXML要素名</param>
        /// <param name="builder">結果のファクトリ</param>
        /// <param name="finder">要素から抽出を行うFinder</param>
        public PagingQueryProvider(string apiKey, string baseUrl, string name, Func<IEnumerable<XElement>, T> builder, EqualsFinder<T> finder)
        {
            this.start = 0;
            this.key = apiKey;
            this.baseUrl = baseUrl;
            this.name = name;
            this.resultBuilder = builder;
            this.finder = finder;
        }

        protected override IEnumerable<T> GetResult(Expression expression)
        {
            InnermostFinder innerFinder = new InnermostFinder();
            var sb = new StringBuilder(baseUrl);
            sb.AppendFormat("?key={0}", key);
            if (finder != null)
            {
                MethodCallExpression whereExpression = innerFinder.GetInnermostWhere(expression);
                if (whereExpression != null)
                {
                    LambdaExpression lambdaExpression = (LambdaExpression)((UnaryExpression)(whereExpression.Arguments[1])).Operand;
                    // Send the lambda expression through the partial evaluator.
                    lambdaExpression = (LambdaExpression)Evaluator.PartialEval(lambdaExpression);
                    finder.Expression = lambdaExpression.Body;

                    foreach (var item in finder.Results)
                    {
                        sb.AppendFormat("&{0}={1}", item.Key, item.Value);
                    }
                }
            }

            MethodCallExpression skipExpression = innerFinder.GetInnermostSkip(expression);
            if (skipExpression != null)
            {
                this.start = int.Parse(ExpressionTreeHelpers.GetValueFromExpression(skipExpression.Arguments[1]));
            }

            MethodCallExpression takeExpression = innerFinder.GetInnermostTake(expression);
            if (takeExpression != null)
            {
                this.takeCount = int.Parse(ExpressionTreeHelpers.GetValueFromExpression(takeExpression.Arguments[1]));
            }

            var url = sb.ToString();

            var executeUrl = url + string.Format("&start={0}&count=30", start + 1);
            var element = XDocument.Load(executeUrl);

            //エラーチェック
            var error = element.Descendants("{http://webservice.recruit.co.jp/HotPepper/}error").FirstOrDefault();
            if (error != null) throw new InvalidQueryException(new Error(error).Message);

            //クエリー条件にマッチする、検索結果の全件数
            var total = int.Parse(element.Descendants("{http://webservice.recruit.co.jp/HotPepper/}results_available").FirstOrDefault().Value);
            //このＸＭＬに含まれる検索結果の件数クエリー条件にマッチする、検索結果の全件数
            var returned = int.Parse(element.Descendants("{http://webservice.recruit.co.jp/HotPepper/}results_returned").FirstOrDefault().Value);
            //検索結果の開始位置
            var resultStart = int.Parse(element.Descendants("{http://webservice.recruit.co.jp/HotPepper/}results_start").FirstOrDefault().Value);

            var collection = element.Descendants("{http://webservice.recruit.co.jp/HotPepper/}" + name);

            var limit =total;

            if (takeCount.HasValue) limit = takeCount.Value + start;

            //残りがあるなら残りのリクエストをシーケンスにくっつけておく
            if (resultStart + returned < limit)
            {
                //次の呼び出しのためにカウンタを進めておく
                index = start + returned;
                collection = collection.Concat(this.GetResultCore(url));
            }
            if (takeCount.HasValue)
            {
                collection.Take(takeCount.Value);
            }
            yield return resultBuilder(collection);
        }
        /// <summary>
        /// 繰り返し部分の取得実体
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        private IEnumerable<XElement> GetResultCore(string url)
        {
            //取得ループ開始
            while (true)
            {
                var executeUrl = url + string.Format("&start={0}&count=30", index + 1);

                var element = XDocument.Load(executeUrl);

                //エラーチェック
                var error = element.Descendants("{http://webservice.recruit.co.jp/HotPepper/}error").FirstOrDefault();
                if (error != null) throw new InvalidQueryException(new Error(error).Message);

                //クエリー条件にマッチする、検索結果の全件数
                var total = element.Descendants("{http://webservice.recruit.co.jp/HotPepper/}results_available").FirstOrDefault();
                // このＸＭＬに含まれる検索結果の件数クエリー条件にマッチする、検索結果の全件数
                var returned = element.Descendants("{http://webservice.recruit.co.jp/HotPepper/}results_returned").FirstOrDefault();
                //結果がなければ終了
                if (total == null || total.Value == "0" || returned == null || returned.Value == "0") yield break;

                var collection = element.Descendants("{http://webservice.recruit.co.jp/HotPepper/}" + name);

                var limit = int.Parse(total.Value);

                if (takeCount.HasValue) limit = takeCount.Value + start;

                foreach (var item in collection)
                {
                    index++;
                    if(index > limit) yield break;
                    yield return item;
                }
            }
        }
    }
}
ひとまずこれで完成。

他のWebServiceもこれらをベースにすればLinq化するのも楽かもしれません。まぁWebはXML or JSONで十分って気がしないでもないですが^^;

Linq to 色々その３．汎用的な呼び出しのベースを作成する。

黒龍 — Mon, 09 Jan 2012 01:32:00 GMT

前回（Linq to 色々その２）、前々回（Linq to 色々）に引き続きIQueryableの残りを作っていきます。

Where句を抽出してWeb Serviceのパラメータとするところまでは概ねうまくいっていたのですが気になる現象がみられました。

それはWhere指定した条件が最終的な列挙にも使用されているという現象です。（なので結果セットを作るところでkeywordとかを詰めなおしていた）

これはExpressionTreeからWhereを評価後に該当するWhere句を取っ払ってしまえばよく、そのためのExpressionTreeModifier<T>というクラスが存在していますので中身にWhere句部分を取っ払うようにしてみましょう。

Where句というのはWhereの抽出で行っていた中身にあるように実質はWhereメソッドの呼び出しになります。（Argument[0]が後続のSelect等のクエリ、Argument[1]がWhereの条件部分）なのでここをWhereの抽出時同様にVisitMethodCallをオーバライドするようにしましょう。こうすれば結果セットに対してのWhereはかからなくなるので期待通り結果のみつめればよくなります。

protected override Expression VisitMethodCall(MethodCallExpression node)
{
    if (node.Method.Name == "Where")
        return Visit(node.Arguments[0]);
    return base.VisitMethodCall(node);
}

で、いよいよ大物のグルメサーチAPIと行きたいところですがマスタ類も結局は必要になるので先にかたずけるとしましょう。前回ページング対応のものは作ったのですが同じ形でAPI毎に作るというのも面倒なのでほとんどのマスタ系呼び出しに共通するページングなしのQueryProviderを作成しましょう。

やりたいこととしては

URLを切り替えれるようにする
結果のXMLから抽出するタグ名を指定できるように
検索条件があれば指定できるように

あたりの事が出来ればひとまずよさそうです。というわけで。。。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Linq.Expressions;
using System.Xml.Linq;
using System.Xml;
using System.Net;

namespace LinqToHotpepper
{
    /// <summary>
    /// ファクトリクラス
    /// </summary>
    public static class SimpleQueryProvider
    {
        /// <summary>
        /// ファクトリメソッド
        /// </summary>
        /// <param name="apiKey">発行されたAPIキー</param>
        /// <param name="baseUrl">リクエストURL</param>
        /// <param name="name">抽出対象のXML要素名</param>
        /// <param name="builder">結果のファクトリ</param>
        public static SimpleQueryProvider<T> Create<T>(string apiKey, string baseUrl, string name, Func<IEnumerable<XElement>, T> builder)
        {
            return new SimpleQueryProvider<T>(apiKey, baseUrl, name, builder, null);
        }
        /// <summary>
        /// ファクトリメソッド
        /// </summary>
        /// <param name="apiKey">発行されたAPIキー</param>
        /// <param name="baseUrl">リクエストURL</param>
        /// <param name="name">抽出対象のXML要素名</param>
        /// <param name="builder">結果のファクトリ</param>
        /// <param name="finder">要素から抽出を行うFinder</param>
        public static SimpleQueryProvider<T> Create<T>(string apiKey, string baseUrl, string name, Func<IEnumerable<XElement>, T> builder, EqualsFinder<T> finder)
        {
            return new SimpleQueryProvider<T>(apiKey, baseUrl, name, builder, finder);
        }
    }
    public class SimpleQueryProvider<T> : QueryProviderBase<T>
    {
        /// <summary>発行されたAPIキー</summary>
        private string key;
        /// <summary>リクエストURL</summary>
        private string baseUrl;
        /// <summary>要素から抽出を行うFinder</summary>
        private EqualsFinder<T> finder;
        /// <summary>抽出対象のXML要素名</summary>
        private string name;
        /// <summary>結果セットのファクトリ</summary>
        private Func<IEnumerable<XElement>, T> resultBuilder;

        /// <summary>
        /// コンストラクタ
        /// </summary>
        /// <param name="apiKey">発行されたAPIキー</param>
        /// <param name="baseUrl">リクエストURL</param>
        /// <param name="name">抽出対象のXML要素名</param>
        /// <param name="builder">結果のファクトリ</param>
        /// <param name="finder">要素から抽出を行うFinder</param>
        public SimpleQueryProvider(string apiKey, string baseUrl, string name, Func<IEnumerable<XElement>, T> builder, EqualsFinder<T> finder)
        {
            this.key = apiKey;
            this.baseUrl = baseUrl;
            this.name = name;
            this.resultBuilder = builder;
            this.finder = finder;
        }
        /// <summary>
        /// パラメータチェック
        /// </summary>
        /// <param name="finder"></param>
        /// <returns></returns>
        private bool IsValidParameter(EqualsFinder<ShopResult> finder)
        {
            return true;
        }

        protected override IEnumerable<T> GetResult(Expression expression)
        {
            var sb = new StringBuilder(baseUrl);
            sb.AppendFormat("?key={0}", key);
            if (finder != null)
            {
                finder.Expression = expression;
                foreach (var item in finder.Results)
                {
                    sb.AppendFormat("&{0}={1}", item.Key, item.Value);                    
                }
            }

            var element = XDocument.Load(sb.ToString());

            //エラーチェック
            var error = element.Descendants("{http://webservice.recruit.co.jp/HotPepper/}error").FirstOrDefault();
            if (error != null) throw new InvalidQueryException(new Error(error).Message);

            var collection = element.Descendants("{http://webservice.recruit.co.jp/HotPepper/}" + name);

            yield return resultBuilder(collection);
        }
    }
}

SimpleQueryProvider<T>ですがQueryProviderBase<T> （abstractだったのでQueryProviderからQueryProviderBaseに名称変えました）をシンプルに実装しただけですね。同名のSimpleQueryProviderクラスはSimpleQueryProvider<T>に対するファクトリです。ジェネリッククラスのコンストラクタはいちいち<T>を書かないとダメなんですがジェネリックメソッドは引数からの型推論が効くのでジェネリックメソッドにはだいたい作っちゃうことが多いです。

こうすることでnew Query<ResultBase<CodeName>>(new SimpleQueryProvider<ResultBase<CodeName>>(...

なんて書き方がQuery.Create(SimpleQueryProvider.Create(...ですんじゃうので。で、呼び出し方はそのまんまですが

var foodQuery = Query.Create(SimpleQueryProvider.Create(
            <APIキー>,
            "http://webservice.recruit.co.jp/hotpepper/food/v1/",
            "food",
             x => new FoodResult()
             {
                 Results = x.Select(_ => new Food(_))
             },
             EqualsFinder.Creater((FoodResult _) => _.code
                , _ => _.keyword,
                _ => _.food_category)));
var query = from result in foodQuery
            from food in result.Results
            where result.keyword == "料理"
            select food;

foreach (var item in query)
{
    System.Diagnostics.Debug.WriteLine(item.Name);
}

みたいな感じにすることでOK。ページング対応の部分も必要なので前回のShopInfoQueryProviderをもとに今回のような汎用的な検索のページングバージョンを作成しましょう。

長くなったので続く。