Używam usługi aplikacji UWP od F #

Question

Uciekam się, aby utworzyć dostawcę usług aplikacji Universal Platform (UWP) w języku C#, ponieważ biblioteka, której chcę użyć, jest dostępna tylko w aplikacjach UWP.

Jednak muszę napisać aplikację (konsolę) w F #, która następnie wywoła powyższego dostawcę usług UWP, aby skorzystać z biblioteki.

Zgodnie z https://msdn.microsoft.com/en-us/windows/uwp/launch-resume/how-to-create-and-consume-an-app-service można to zrobić, jeśli zarówno dostawca usług, jak i konsument, są zapisani w języku C# za pomocą UWP (ponieważ F # nie jest jeszcze obsługiwany w UWP).

Moje pytanie brzmi, czy mogę zadzwonić do usługi aplikacji UWP napisanej w języku C# z projektu F #? Czy mogę utworzyć rozwiązanie z dwoma projektami, z których jednym jest dostawca usług aplikacji UWP C#, a drugie jest konsumentem usługi aplikacji konsolowej F #?

Answer 1

Oto ulepszona wersja mojego kodu z drugiego postu, do którego linkowałem powyżej, który dodatkowo mapuje obiekty asynchroniczne WinRT do F # Async<_>, co sprawia, że ​​praca z niektórymi typami jest o wiele przyjemniejsza.

open System.Reflection 

type Asyncifier() = 
    static let winrtExts = System.Type.GetType("System.WindowsRuntimeSystemExtensions, System.Runtime.WindowsRuntime, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089") 
    static let asTask = winrtExts.GetMethods() |> Seq.find(fun m -> m.Name = "AsTask" && m.IsGenericMethodDefinition && m.GetGenericArguments().Length = 1 && m.ReturnType.IsGenericType) 
    static member FromTask<'t,'u>(t:System.Threading.Tasks.Task<'t>) = 
     async { 
      let! t = Async.AwaitTask t 
      return box t :?> 'u 
     } 
    static member FromIAsyncObjThrough<'t>(argTy, o) : Async<'t> = 
     typeof<Asyncifier>.GetMethod("FromTask").MakeGenericMethod(argTy, typeof<'t>).Invoke(null, [| asTask.MakeGenericMethod(argTy).Invoke(null, [|o|]) |]) :?> _ 

let getWindowsType (name:string) = 
    let ns = let parts = name.Split('.') in parts.[0] + "." + parts.[1] 
    System.Type.GetType(sprintf "%s, %s, Version=255.255.255.255, Culture=neutral, PublicKeyToken=null, ContentType=WindowsRuntime" name ns) 

let IAsyncOperation = getWindowsType "Windows.Foundation.IAsyncOperation`1" 

let (?) (o:obj) s : 'a = 
    let rec build ty args = 
     if Reflection.FSharpType.IsFunction ty then 
      let dom, rng = Reflection.FSharpType.GetFunctionElements ty 
      let mkArgs = 
       if dom = typeof<unit> then 
        if Reflection.FSharpType.IsFunction rng then failwith "Unit as non-final argument in curried definition?" 
        fun _ -> args 
       else 
        fun arg -> arg::args 
      Reflection.FSharpValue.MakeFunction(ty, fun o -> build rng (mkArgs o)) 
     else 
      let rcvr,ty,flags = 
       match o with 
       | :? System.Type as ty -> null,ty,BindingFlags.Static 
       | _ -> o,o.GetType(),BindingFlags.Instance 
      let flags = flags ||| BindingFlags.Public 
      let meth = 
       if Reflection.FSharpType.IsFunction typeof<'a> then 
        query { 
         for m in ty.GetMethods(flags) do 
         where (m.Name = s) 
         where (m.GetParameters().Length = args.Length) 
         exactlyOne 
        }      
       else 
        ty.GetProperty(s, flags).GetGetMethod() 
      let result = meth.Invoke(rcvr, args |> List.toArray) 
      let resultTy = 
       let rec resultTy ty = 
        if Reflection.FSharpType.IsFunction ty then Reflection.FSharpType.GetFunctionElements ty |> snd |> resultTy 
        else ty 
       resultTy typeof<'a> 
      let (|GenericTypeInstance|_|) (genTy:System.Type) (ty:System.Type) = 
       if ty.IsGenericType && ty.GetGenericTypeDefinition() = genTy then Some (ty.GetGenericArguments()) 
       else None 
      let asyncTy = typedefof<Async<_>> 
      match meth.ReturnType, resultTy with 
      | GenericTypeInstance IAsyncOperation [|winRtTy|], GenericTypeInstance asyncTy [|returnTy|] -> 
       // unwrap to F# async 
       typeof<Asyncifier>.GetMethod("FromIAsyncObjThrough").MakeGenericMethod(returnTy).Invoke(null, [|winRtTy; result|]) 
      | _ -> result 
    build typeof<'a> [] :?> 'a 

A oto jak można go użyć do zrobienia OCR:

let Language = getWindowsType @"Windows.Globalization.Language" 
let OcrEngine = getWindowsType "Windows.Media.Ocr.OcrEngine" 
let BitmapDecoder = getWindowsType "Windows.Graphics.Imaging.BitmapDecoder" 
let StorageFile = getWindowsType "Windows.Storage.StorageFile" 

let enUs = Language.GetConstructor([|typeof<string>|]).Invoke([|"en-US"|]) 
let engine : obj = OcrEngine?TryCreateFromLanguage enUs 

let getTextAsync (path:string) : Async<string> = async { 
    let! file = StorageFile?GetFileFromPathAsync path 
    let! stream = file?OpenReadAsync() 
    let! decoder = BitmapDecoder?CreateAsync stream 
    let! bitmap = decoder?GetSoftwareBitmapAsync() 
    let! result = engine?RecognizeAsync bitmap 
    return result?Text 
}