Esempio n. 1
0
        /// <summary>
        /// Registers the default type handlers.
        /// </summary>
        ///
        private static Dictionary <Guid, ThingTypeHandler> RegisterDefaultTypeHandlers(
            out Dictionary <string, ThingTypeHandler> typeHandlersByClassName)
        {
            Dictionary <Guid, ThingTypeHandler> typeHandlers =
                new Dictionary <Guid, ThingTypeHandler>();

            typeHandlersByClassName =
                new Dictionary <string, ThingTypeHandler>(
                    StringComparer.OrdinalIgnoreCase);

            foreach (DefaultTypeHandler typeHandler in s_defaultTypeHandlers)
            {
                ThingTypeHandler handler =
                    new ThingTypeHandler(typeHandler.TypeId, typeHandler.Type);

                typeHandlers.Add(
                    typeHandler.TypeId,
                    handler);

                typeHandlersByClassName.Add(
                    typeHandler.TypeName,
                    handler);
            }

            return(typeHandlers);
        }
Esempio n. 2
0
        /// <summary>
        /// Registers a deserializer for item type-specific data.
        /// </summary>
        ///
        /// <param name="typeId">
        /// The unique identifier for the item type-specific data as defined
        /// by the HealthVault service.
        /// </param>
        ///
        /// <param name="itemTypeClass">
        /// The class that implements the item type-specific data. It must
        /// be public, derive from <see cref="ThingBase"/>, and
        /// have a default constructor.
        /// </param>
        ///
        /// <param name="overwriteExisting">
        /// <b>true</b> to register the new deserializer even if the type
        /// already has a deserializer registered; <b>false</b> to throw an
        /// exception because a deserializer is already registered.
        /// </param>
        ///
        /// <exception cref="ArgumentException">
        /// The <paramref name="typeId"/> parameter is <see cref="System.Guid.Empty"/> or
        /// the <paramref name="itemTypeClass"/> parameter does not derive from
        /// <see cref="ThingBase"/>.
        /// </exception>
        ///
        /// <exception cref="ArgumentNullException">
        /// The <paramref name="itemTypeClass"/> parameter is <b>null</b>.
        /// </exception>
        ///
        /// <exception cref="TypeHandlerAlreadyRegisteredException">
        /// The <paramref name="typeId"/> parameter already has a handler
        /// registered and <paramref name="overwriteExisting"/> is <b>false</b>.
        /// </exception>
        ///
        public static void RegisterTypeHandler(
            Guid typeId,
            Type itemTypeClass,
            bool overwriteExisting = false)
        {
            if (typeId == Guid.Empty)
            {
                throw new ArgumentException(Resources.TypeIdGuidEmpty, nameof(typeId));
            }

            Validator.ThrowIfArgumentNull(itemTypeClass, nameof(itemTypeClass), Resources.ThingTypeClassNull);

            if (!itemTypeClass.GetTypeInfo().IsSubclassOf(typeof(ThingBase)))
            {
                throw new ArgumentException(Resources.TypeClassNotThing, nameof(itemTypeClass));
            }

            if (TypeHandlers.ContainsKey(typeId) && !overwriteExisting)
            {
                throw new TypeHandlerAlreadyRegisteredException(Resources.TypeHandlerAlreadyRegistered);
            }

            TypeHandlers[typeId] = new ThingTypeHandler(typeId, itemTypeClass);
            s_typeHandlersByClassName[itemTypeClass.Name] = TypeHandlers[typeId];
        }
Esempio n. 3
0
        /// <summary>
        /// Gets the <see cref="Type"/> instance of the class that is registered to
        /// handle this type id.
        /// </summary>
        /// <remarks>
        /// This method looks up the type id in the list of types that the SDK understands how
        /// to process. If new types were added to the HealthVault service since this SDK was
        /// released, this method will not return them.
        ///
        /// To retrieve information about the types from the HealthVault service,
        /// use the <see cref="GetHealthRecordItemTypeDefinitionAsync(IConnectionInternal)"/> method.
        /// </remarks>
        /// <param name="typeId">The ID of the associated type</param>
        /// <returns>The typeId.</returns>
        public static Type GetRegisteredTypeForTypeId(Guid typeId)
        {
            if (TypeHandlers.ContainsKey(typeId))
            {
                ThingTypeHandler itemTypeHandler = TypeHandlers[typeId];
                return(itemTypeHandler.ItemTypeClass);
            }

            return(null);
        }
Esempio n. 4
0
        internal static ThingBase DeserializeItem(XPathNavigator thingNav)
        {
            ThingBase result;
            Guid      typeId = GetTypeId(thingNav);

            ThingTypeHandler handler = null;

            if (typeId == s_applicationSpecificId)
            {
                // Handle application specific health item records by checking for handlers
                // for the application ID and subtype tag. If the handler doesn't exist
                // the default handler will be picked up below.

                AppDataKey appDataKey = GetAppDataKey(thingNav);

                if (appDataKey != null)
                {
                    if (s_appSpecificHandlers.ContainsKey(appDataKey.AppId))
                    {
                        if (s_appSpecificHandlers[appDataKey.AppId].ContainsKey(appDataKey.SubtypeTag))
                        {
                            handler =
                                s_appSpecificHandlers[appDataKey.AppId][appDataKey.SubtypeTag];
                        }
                    }
                }
            }

            if (handler == null &&
                TypeHandlers.ContainsKey(typeId))
            {
                handler = TypeHandlers[typeId];
            }

            if (handler != null)
            {
                result = (ThingBase)Activator.CreateInstance(handler.ItemTypeClass);
            }
            else
            {
                result = new ThingBase(typeId);
            }

            result.ParseXml(thingNav, thingNav.OuterXml);

            return(result);
        }
Esempio n. 5
0
        /// <summary>
        /// Registers a deserializer for item extension data.
        /// </summary>
        ///
        /// <remarks>
        /// Extension data is available to all applications, and since there is no registration
        /// method for the extensionSource identifiers, collisions between applications are possible.
        ///
        /// Applications should be written to be tolerant of the presence of extension data using the
        /// same extensionSource but a different schema. It is also recommended that extensionSource be
        /// specified the same way .NET namespaces are specified, prefixing the extensionSource with the
        /// company name.
        /// </remarks>
        ///
        /// <param name="extensionSource">
        /// The unique identifier for the source of the item extension.
        /// </param>
        ///
        /// <param name="itemExtensionClass">
        /// The class that implements the item extension. It must
        /// be public, derive from <see cref="ThingExtension"/>,
        /// and have a default constructor.
        /// </param>
        ///
        /// <param name="overwriteExisting">
        /// <b>true</b> to register the new deserializer even if the type
        /// already has a deserializer registered; <b>false</b> to throw an
        /// exception because a deserializer is already registered.
        /// </param>
        ///
        /// <exception cref="ArgumentException">
        /// The <paramref name="extensionSource"/> parameter is <b>null</b> or empty or
        /// the <paramref name="itemExtensionClass"/> parameter does not derive from
        /// <see cref="ThingExtension"/>.
        /// </exception>
        ///
        /// <exception cref="ArgumentNullException">
        /// The <paramref name="itemExtensionClass"/> parameter is <b>null</b>.
        /// </exception>
        ///
        /// <exception cref="TypeHandlerAlreadyRegisteredException">
        /// The <paramref name="extensionSource"/> already has a handler
        /// registered and <paramref name="overwriteExisting"/> is <b>false</b>.
        /// </exception>
        ///
        public static void RegisterExtensionHandler(
            string extensionSource,
            Type itemExtensionClass,
            bool overwriteExisting)
        {
            Validator.ThrowIfStringNullOrEmpty(extensionSource, "extensionSource");
            Validator.ThrowIfArgumentNull(itemExtensionClass, nameof(itemExtensionClass), Resources.ItemExtensionClassNull);

            if (s_extensionHandlers.ContainsKey(extensionSource) &&
                !overwriteExisting)
            {
                throw new TypeHandlerAlreadyRegisteredException(Resources.ExtensionHandlerAlreadyRegistered);
            }

            s_extensionHandlers[extensionSource] =
                new ThingTypeHandler(itemExtensionClass);
        }
Esempio n. 6
0
        /// <summary>
        /// Deserializes the response XML for extensions into a
        /// <see cref="ThingExtension"/> or derived type based on the registered
        /// extension handler.
        /// </summary>
        ///
        /// <param name="extensionNav">
        /// The XML representation of the extension data.
        /// </param>
        ///
        /// <returns>
        /// The <see cref="ThingExtension"/> or derived class instance
        /// representing the data in the XML.
        /// </returns>
        ///
        /// <exception cref="System.Reflection.TargetInvocationException">
        /// If the constructor of the type being created throws an
        /// exception. The inner exception is the exception thrown by the
        /// constructor.
        /// </exception>
        ///
        /// <exception cref="MissingMethodException">
        /// The default constructor of the type being created is not public.
        /// If you registered the extension handler, be sure that the type you
        /// registered for the extension type class has a public default
        /// constructor.
        /// </exception>
        ///
        internal static ThingExtension DeserializeExtension(
            XPathNavigator extensionNav)
        {
            ThingExtension result;

            string source = extensionNav.GetAttribute("source", string.Empty);

            if (s_extensionHandlers.ContainsKey(source))
            {
                ThingTypeHandler handler = s_extensionHandlers[source];
                result =
                    (ThingExtension)Activator.CreateInstance(
                        handler.ItemTypeClass);
            }
            else
            {
                result = new ThingExtension(source);
            }

            result.ParseXml(extensionNav);
            return(result);
        }
Esempio n. 7
0
        /// <summary>
        /// Registers a class as the handler for the application specific health record
        /// item type with the specific application ID and subtype tag.
        /// </summary>
        ///
        /// <param name="applicationId">
        /// The application identifier for the application specific data that the
        /// specified type will handle.
        /// </param>
        ///
        /// <param name="subtypeTag">
        /// The subtype tag for the application specific data that the specified type
        /// will handle.
        /// </param>
        ///
        /// <param name="applicationSpecificHandlerClass">
        /// The .NET type that handles parsing of the application specific data for
        /// the specified application ID and subtype tag.
        /// </param>
        ///
        /// <param name="overwriteExisting">
        /// If true and an entry exist for the specified <paramref name="applicationId"/>
        /// and <paramref name="subtypeTag"/> it will be replaced.
        /// </param>
        ///
        /// <exception cref="ArgumentException">
        /// If <paramref name="applicationId"/> or <paramref name="subtypeTag"/> is
        /// <b>null</b> or empty, or if <paramref name="applicationSpecificHandlerClass"/>
        /// does not derive from ApplicationSpecific.
        /// </exception>
        ///
        /// <exception cref="ArgumentNullException">
        /// If <paramref name="applicationSpecificHandlerClass"/> is <b>null</b>.
        /// </exception>
        ///
        /// <exception cref="TypeHandlerAlreadyRegisteredException">
        /// If a type is already registered to handle the application specific data
        /// for the specified <paramref name="applicationId"/> and
        /// <paramref name="subtypeTag"/> and <paramref name="overwriteExisting"/> is false.
        /// </exception>
        ///
        public static void RegisterApplicationSpecificHandler(
            string applicationId,
            string subtypeTag,
            Type applicationSpecificHandlerClass,
            bool overwriteExisting)
        {
            Validator.ThrowIfStringNullOrEmpty(applicationId, "applicationId");
            Validator.ThrowIfStringNullOrEmpty(subtypeTag, "subtypeTag");
            Validator.ThrowIfArgumentNull(applicationSpecificHandlerClass, nameof(applicationSpecificHandlerClass), Resources.AppDataHandlerClassMandatory);

            if (applicationSpecificHandlerClass.GetTypeInfo().BaseType.Name != nameof(ApplicationSpecific))
            {
                throw new ArgumentException(Resources.AppDataHandlerNotApplicationSpecific, nameof(applicationSpecificHandlerClass));
            }

            Dictionary <string, ThingTypeHandler> handlerDictionary;

            if (s_appSpecificHandlers.ContainsKey(applicationId))
            {
                handlerDictionary = s_appSpecificHandlers[applicationId];

                if (handlerDictionary.ContainsKey(subtypeTag) &&
                    !overwriteExisting)
                {
                    throw new TypeHandlerAlreadyRegisteredException(Resources.AppDataHandlerAlreadyRegistered);
                }
            }
            else
            {
                handlerDictionary = new Dictionary <string, ThingTypeHandler>();
                s_appSpecificHandlers.Add(applicationId, handlerDictionary);
            }

            ThingTypeHandler handler =
                new ThingTypeHandler(applicationSpecificHandlerClass);

            handlerDictionary[subtypeTag] = handler;
        }