partir - xsd visual studio 2017

¿Hay alguna manera de generar un.xsd para tipos F#?

Question

Estamos buscando aprovechar F # para nuestros proyectos en el futuro, y nos gustaría poder generar esquemas .xsd de tipos F # automáticamente.

La búsqueda en la Web arroja muchas respuestas para generar tipos desde .xsd, pero no al revés.

¿Alguien sabe de una manera de hacer esto?

Answer 1

Ese tipo de depende de lo que realmente quieres decir.

Si quisiste decir: "¿Cómo puedo generar XSD desde dll?" entonces puede ser simplemente hecho con svcutil ... Ok, dado que se cumplen algunas otras condiciones, pero más o menos factibles:

El siguiente comando genera documentos de metadatos para contratos de servicio y tipos asociados en un ensamblaje.

svcutil myAssembly.dll

https://msdn.microsoft.com/en-us/library/aa347733(v=vs.110).aspx

xsd.exe también debería ser capaz de hacer casi lo mismo. Aunque no estoy seguro de en qué condiciones, pero los documentos no son tan "estrictos" como svcutil.

El siguiente comando genera esquemas XML para todos los tipos en el conjunto myAssembly.dll y los guarda como schema0.xsd en el directorio actual.

xsd myAssembly.dll 

https://msdn.microsoft.com/en-us/library/x6c1kb0s(v=vs.110).aspx

Si quisiste decir "generar XSD a partir del archivo * .fs dado", entonces estás un poco fuera de suerte (que yo sepa).

Answer 2

Me acercaría a esto usando ''clases de tipos''. Ejemplo rápido (en REPL). Supongamos que tiene un tipo de Person , como type Person = { id : int64; name : string} type Person = { id : int64; name : string} . Entonces:

> ("id", Xsd.int64, "name", Xsd.string)
  |> Xsd.record2 "Person"
  |> Xsd.root
  |> Xsd.to_string;;
val it : string =
  "<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <xsd:complexType name="Person">
  <xsd:sequence>
    <xsd:element name="id" type="long"/>
    <xsd:element name="name" type="string"/>
  </xsd:sequence>
</xsd:complexType>
</xsd:schema>"

Esto funciona poniendo pequeñas funciones de conversión para cada tipo en el módulo Xsd , y también para combinaciones de tipos, es decir, suma y tipos de productos. Eso debería cubrir la mayoría de las necesidades. Cómo se vería el módulo Xsd :

(* xsd.fsi *)

/// Just a string marked by the type of data whose XSD it holds.
/// Implementation is private so that callers can''t create any XSD
/// they like.
type ''a t

/// Gives us the string representation of the XSD.
val to_string : ''a t -> string

/// Wraps an XSD encoding inside the <xsd:schema> tag pair.
val root : ''a t -> ''a t

// Primitive types.

val int : int t
val int64 : int64 t
val string : string t

/// Encode a two-field record''s type (name and fields along with their
/// types) as XSD.
val record2 : string -> string * ''a1 t * string * ''a2 t -> ''a t

(* xsd.fs *)

type ''a t = { to_string : string }

let to_string xsd = xsd.to_string
let root xsd =
  { to_string =
      sprintf "<xsd:schema xmlns:xsd=/"http://www.w3.org/2001/XMLSchema/">
  %s
</xsd:schema>" xsd.to_string }

let int = { to_string = "integer" }
let int64 = { to_string = "long" }
let string = { to_string = "string" }

/// Helper for record fields.
let element name typ =
  sprintf "<xsd:element name=/"%s/" type=/"%s/"/>" name typ

let record2 name (field1, xsd1, field2, xsd2) =
  { to_string =
      sprintf
        "<xsd:complexType name=/"%s/">
  <xsd:sequence>
    %s
    %s
  </xsd:sequence>
</xsd:complexType>"
        name
        (element field1 xsd1.to_string)
        (element field2 xsd2.to_string) }

Es cierto que esta es una técnica desconocida en comparación con el uso de la reflexión en tiempo de ejecución. Pero también es más seguro para los tipos y te da un control más detallado sobre la codificación. Probablemente tampoco necesites implementar todo el XSD; solo necesitas las partes que realmente usan tus tipos.

Answer 3

Podría estar equivocado, pero no veo cómo esto se puede lograr de una manera que lo haría más práctico que usar un proveedor de tipo F # basado en XSD, si hay uno que funcione suficientemente bien. Pero entonces, no estoy seguro de que haya uno.

Pruebe el proveedor de tipo FSharp.Data.Xsd. Puede especificar XSD directamente en el origen como una cadena o haciendo referencia a un archivo XSD externo a la fuente. Es posible que no pueda crear ningún XSD que pueda desear.

El problema, creo, es que los tipos F # solos no son una forma práctica de especificar cómo debería verse el XSD, a menos que haga algún compromiso que tal vez no esté preparado para hacer.

• ¿Crearías algunos tipos específicos en F # para controlar el mapeo? No creo que tener que usar esos tipos sería "aprovechar F #".

• ¿Usaría atributos de código u otros metadatos? En ese caso, ¿no es mejor editar el XSD en lugar de los tipos F #?

• ¿Simplemente crearías algunas reglas que impliquen un mapeo de uno a uno? Podría funcionar, pero podría no producir el XSD y XML que desea. Podría ser demasiado detallado.

Deberías generar el XSD. Si, por otro lado, utiliza un proveedor de tipos para generar los tipos F # de XSD, los tipos generados estarán disponibles al instante. ¿No es mucho más práctico y agradable?

Answer 4

Si desea generar XSD de cualquier tipo directamente desde su código, entonces eche un vistazo a este script F #. Genera un tipo de registro XSD de F #. Script utiliza tres ensamblados .NET: System.Runtime.Serialization.dll , System.Runtime.Serialization.Xml , System.Xml .

#r "System.Runtime.Serialization.dll"
#r "System.Runtime.Serialization.Xml.dll"
#r "System.Xml.dll"

open System
open System.IO
open System.Linq
open System.Text
open System.Text.RegularExpressions
open System.Xml
open System.Runtime.Serialization

type [<DataContract>] CommitInfo = { 
  [<field: DataMember(Name="id") >]
  id: string
  [<field: DataMember(Name="date") >]
  date: DateTime 
  [<field: DataMember(Name="issueUrl") >]
  issueUrl: string
  [<field: DataMember(Name="issueId") >]
  issueId: int
  [<field: DataMember(Name="message") >]
  message: string
  [<field: DataMember(Name="url") >]
  url: string 
}

let getXmlWriter (stream: Stream) = 
    //let utf8noBOM = new UTF8Encoding(false)
    let settings = new XmlWriterSettings()
    settings.Indent <- true
    settings.Encoding <- Encoding.UTF8  
    //settings.OmitXmlDeclaration <- true
    XmlWriter.Create(stream, settings)

let streamToString (stream: Stream) = 
    stream.Position <- int64 0
    use sr = new StreamReader(stream)
    sr.ReadToEnd()

let getResultFromStream (streamWriter: Stream -> unit) = 
    use stream = new MemoryStream ()
    streamWriter stream
    streamToString stream

let exporter = XsdDataContractExporter()
exporter.Export(typeof<CommitInfo array>)
let schemas = exporter.Schemas.Schemas().Cast<Schema.XmlSchema>() |> Array.ofSeq
let schema = schemas.[1]

fun s -> s |> getXmlWriter |> schema.Write
|> getResultFromStream 
|> printfn "%s"