コード例 #1
0
ファイル: Serializer.cs プロジェクト: MuraStranger/XRoadLib
        public Serializer(SchemaDefinitionProvider schemaDefinitionProvider, uint?version = null)
        {
            this.schemaDefinitionProvider = schemaDefinitionProvider;

            availableFilters  = schemaDefinitionProvider.ProtocolDefinition.EnabledFilters;
            contractAssembly  = schemaDefinitionProvider.ProtocolDefinition.ContractAssembly;
            producerNamespace = schemaDefinitionProvider.ProtocolDefinition.ProducerNamespace;

            Version = version;

            AddSystemType <DateTime>("dateTime", x => new DateTimeTypeMap(x));
            AddSystemType <DateTime>("date", x => new DateTypeMap(x));

            AddSystemType <TimeSpan>("duration", x => new TimeSpanTypeMap(x));

            AddSystemType <bool>("boolean", x => new BooleanTypeMap(x));

            AddSystemType <float>("float", x => new SingleTypeMap(x));
            AddSystemType <double>("double", x => new DoubleTypeMap(x));
            AddSystemType <decimal>("decimal", x => new DecimalTypeMap(x));

            AddSystemType <long>("long", x => new Int64TypeMap(x));
            AddSystemType <int>("int", x => new Int32TypeMap(x));
            AddSystemType <short>("short", x => new Int16TypeMap(x));
            AddSystemType <BigInteger>("integer", x => new IntegerTypeMap(x));

            AddSystemType <string>("string", x => new StringTypeMap(x));
            AddSystemType <string>("anyURI", x => new StringTypeMap(x));

            AddSystemType <Stream>("base64Binary", x => new ContentTypeMap(x));
            AddSystemType <Stream>("hexBinary", x => new ContentTypeMap(x));
            AddSystemType <Stream>("base64", x => new ContentTypeMap(x));

            AddSystemType <object>("", x => new AnyContentTypeMap(x, this));
        }
コード例 #2
0
ファイル: XRoadProtocol.cs プロジェクト: jaxx/XRoadLib
        /// <summary>
        /// Initializes new X-Road message protocol instance.
        /// <param name="name">Identifies protocol instance.</param>
        /// <param name="schemaExporter">Schema customization provider.</param>
        /// </summary>
        public XRoadProtocol(string name, ISchemaExporter schemaExporter)
        {
            if (string.IsNullOrEmpty(name))
            {
                throw new ArgumentNullException(nameof(name));
            }

            if (schemaExporter == null)
            {
                throw new ArgumentNullException(nameof(schemaExporter));
            }

            Name = name;

            schemaDefinitionProvider = new SchemaDefinitionProvider(schemaExporter);

            HeaderDefinition   = schemaDefinitionProvider.GetXRoadHeaderDefinition();
            ProtocolDefinition = schemaDefinitionProvider.ProtocolDefinition;

            SetContractAssembly();
        }
コード例 #3
0
        /// <summary>
        /// Initialize builder with contract details.
        /// <param name="protocol">X-Road protocol to use when generating service description.</param>
        /// <param name="schemaDefinitionProvider">Provides overrides for default presentation format.</param>
        /// <param name="version">Global version for service description (when versioning entire schema and operations using same version number).</param>
        /// </summary>
        public ProducerDefinition(IXRoadProtocol protocol, SchemaDefinitionProvider schemaDefinitionProvider, uint?version = null)
        {
            if (protocol == null)
            {
                throw new ArgumentNullException(nameof(protocol));
            }
            this.protocol = protocol;

            if (schemaDefinitionProvider == null)
            {
                throw new ArgumentNullException(nameof(schemaDefinitionProvider));
            }
            this.schemaDefinitionProvider = schemaDefinitionProvider;

            this.version     = version;
            contractAssembly = schemaDefinitionProvider.ProtocolDefinition.ContractAssembly;

            portType = new PortType {
                Name = "PortTypeName"
            };

            binding = new Binding
            {
                Name = "BindingName",
                Type = new XmlQualifiedName(portType.Name, protocol.ProducerNamespace)
            };

            servicePort = new Port
            {
                Name    = "PortName",
                Binding = new XmlQualifiedName(binding.Name, protocol.ProducerNamespace)
            };

            service = new Service
            {
                Name  = "ServiceName",
                Ports = { servicePort }
            };

            CollectTypes();

            var globalNamespaces = new Dictionary <string, string>();

            addGlobalNamespace = (namespaceName) =>
            {
                var prefix = NamespaceConstants.GetPreferredPrefix(namespaceName);
                if (string.IsNullOrEmpty(prefix))
                {
                    return(false);
                }

                globalNamespaces[prefix] = namespaceName;

                return(true);
            };

            getGlobalNamespaces = () => globalNamespaces.Select(x => Tuple.Create(x.Key, x.Value)).ToList();

            var requiredImports = new SortedSet <Tuple <string, string> >();

            addRequiredImport = (schemaNamespace, typeNamespace, schemaExporter) =>
            {
                if (typeNamespace == NamespaceConstants.XSD || typeNamespace == schemaNamespace)
                {
                    return;
                }

                if (!schemaLocations.ContainsKey(typeNamespace))
                {
                    schemaLocations.Add(typeNamespace, schemaDefinitionProvider.GetSchemaLocation(typeNamespace, schemaExporter));
                }

                requiredImports.Add(Tuple.Create(schemaNamespace, typeNamespace));
            };

            getRequiredImports = ns => requiredImports.Where(x => x.Item1 == ns).Select(x => x.Item2).ToList();

            xRoadPrefix      = schemaDefinitionProvider.GetXRoadPrefix();
            xRoadNamespace   = schemaDefinitionProvider.GetXRoadNamespace();
            headerDefinition = schemaDefinitionProvider.GetXRoadHeaderDefinition();

            addGlobalNamespace(NamespaceConstants.SOAP);
            addGlobalNamespace(NamespaceConstants.WSDL);
            addGlobalNamespace(NamespaceConstants.XSD);
        }