Блог

На данный момент это выше моего понимания. Я пытаюсь создать интерфейс, который выглядит примерно так.

 type IFetchData = 
     abstract FetchData: string -> seq<'a>
  

Приведенное выше объявление допустимо (и компилируется), но когда я начинаю его использовать, я получаю ошибку времени компиляции. Ожидалось, что это выражение будет иметь тип ‘a, но здесь имеет тип «то, что я в данный момент пытаюсь вернуть», т. Е. seq .

Однако мой пример использования выглядит следующим образом:

 type SampleFetchData() =
    interface IFetchData with
        member self.FetchData str =           
           seq {
                    for letter in str do
                        yield letter // compile error here
                }
  

Я не уверен, что я делаю неправильно. Все, что я хотел бы сделать, это позволить разработчику интерфейса иметь возможность писать любую функцию, которая возвращает универсальную последовательность либо seq<string> , seq<int> , seq<record type here> , seq<union type here> , и т.д.

Может кто-нибудь сказать мне, чего мне здесь не хватает?

Спасибо.

Если вы загружаете реализацию интерфейса с использованием отражения, то работать с ней будет довольно сложно. Проблема в том, что вы получаете объект типа obj . Вы знаете, что она реализуется IFetchData<'T> для некоторых 'T функций, но статически вы не знаете, для каких 'T . Это проблема, потому что вы не можете привести объект к какому-либо более определенному типу — если бы вы попытались использовать IFetchData<obj> , это не сработало бы, потому что вы не можете привести, например, IFetchData<int> к этому типу.

Я бы рекомендовал использовать неродовой интерфейс, который является довольно распространенным .СЕТЕВОЙ шаблон:

 type IFetchDataUntyped = 
  abstract FetchData : string -> System.Collections.IEnumerable

type IFetchData<'T> =  
  inherit IFetchDataUntyped
  abstract FetchData : string -> seq<'T> 
  

Когда вы загружаете реализацию с использованием отражения, вы можете привести объект к IFetchDataUntyped и работать с ним довольно разумным способом (используя Seq.cast для преобразования последовательности в более конкретный тип, если вы знаете тип элемента).

В зависимости от вашего приложения вы также можете просто сделать FetchData метод универсальным методом и сохранить интерфейс нестандартным. Затем вы могли бы передавать динамически загружаемые объекты в интерфейс и вызывать метод. Однако это меняет дизайн (поскольку метод должен работать для любого типа, который он получает в качестве параметра типа):

 type IFetchData =  
  abstract FetchData<'T> : string -> seq<'T>  // Note: Generic parameter here!
  

Вам нужно сделать что-то вроде

 type IFetchData<'a> = 
     abstract FetchData: string -> seq<'a>

type SampleFetchData() =
    interface IFetchData<char> with
        member self.FetchData str =           
           seq {
                    for letter in str do
                        yield letter 
                }
  

т.е. интерфейс должен быть сделан универсальным. Если вы хотите избежать универсальности, вы могли бы использовать некоторые встроенные ограничения, а не интерфейс

РЕДАКТИРОВАТЬ: встроенная версия magic

 let inline Fetchdata string obj=
   (^a: (member FetchData: string -> seq<'b> )(obj, string))

type SampleFetchData() =
        member self.FetchData str =           
           seq {
                    for letter in str do
                        yield letter 
                }

Fetchdata "hello" (new SampleFetchData())