Pregunta

En C # que puedo hacer:

var castValue = inputValue as Type1

En F #, que puede hacer:

let staticValue = inputValue :> Type1
let dynamicValue = inputValue :?> Type1

Sin embargo, ninguno de ellos es el equivalente a la de C # 's as palabra clave.

supongo que tengo que hacer una expresión de coincidencia por el equivalente en C #

match inputValue with
| :? Type1 as type1Value -> type1Value
| _ -> null

¿Es esto correcto?

¿Fue útil?

Solución

Por lo que yo sé, F # no tiene ningún operador incorporado equivalente a C # as por lo que necesita para escribir una expresión más complicada. Como alternativa a su código usando match, también se puede utilizar if, debido a que el :? operador puede ser el uso de la misma manera como is en C #:

let res = if (inputValue :? Type1) then inputValue :?> Type1 else null

Por supuesto puede escribir una función para encapsular este comportamiento (escribiendo una sencilla función genérica que toma un Object y lo convierte en el parámetro de tipo genérico especificado):

let castAs<'T when 'T : null> (o:obj) = 
  match o with
  | :? 'T as res -> res
  | _ -> null

Esta null rendimientos de ejecución, por lo que requiere que el parámetro de tipo tiene null como un valor adecuado (como alternativa, se puede usar Unchecked.defaultof<'T>, lo que equivale a default(T) en C #). Ahora se puede escribir simplemente:

let res = castAs<Type1>(inputValue)

Otros consejos

Yo usaría un patrón activo. Aquí está el uso de una sola I:

let (|As|_|) (p:'T) : 'U option =
    let p = p :> obj
    if p :? 'U then Some (p :?> 'U) else None

Esta es una muestra de cómo se As:

let handleType x = 
    match x with
    | As (x:int) -> printfn "is integer: %d" x
    | As (s:string) -> printfn "is string: %s" s
    | _ -> printfn "Is neither integer nor string"

// test 'handleType'
handleType 1
handleType "tahir"
handleType 2.
let stringAsObj = "tahir" :> obj
handleType stringAsObj

Puede crear su propio operador para realizar esta acción. Esto es prácticamente idéntica a la del ejemplo de Tomás, pero muestra una forma ligeramente diferente a llamarlo. He aquí un ejemplo:

let (~~) (x:obj) = 
  match x with
  | :? 't as t -> t //'
  | _ -> null

let o1 = "test"
let o2 = 2
let s1 = (~~o1 : string)  // s1 = "test"
let s2 = (~~o2 : string) // s2 = null
  

supongo que tengo que hacer una expresión de coincidencia por el equivalente en C #

     

match inputValue with | :? Type1 as type1Value -> type1Value | _ -> null

     

¿Es esto correcto?

Sí, es correcto. (Su propia respuesta es mejor que el resto de las respuestas en mi opinión.)

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top