/// <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="Microsoft.Health.HealthRecordItem"/>, 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="HealthRecordItem"/>. /// </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) { Validator.ThrowArgumentExceptionIf( typeId == Guid.Empty, "typeId", "TypeIdGuidEmpty"); Validator.ThrowIfArgumentNull(itemTypeClass, "itemTypeClass", "ThingTypeClassNull"); Validator.ThrowArgumentExceptionIf( !itemTypeClass.IsSubclassOf(typeof(HealthRecordItem)), "itemTypeClass", "ThingTypeClassNotHealthRecordItem"); if (TypeHandlers.ContainsKey(typeId) && !overwriteExisting) { throw new TypeHandlerAlreadyRegisteredException( ResourceRetriever.GetResourceString("TypeHandlerAlreadyRegistered")); } TypeHandlers[typeId] = new HealthRecordItemTypeHandler(typeId, itemTypeClass); _typeHandlersByClassName[itemTypeClass.Name] = TypeHandlers[typeId]; }
/// <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, "applicationSpecificHandlerClass", "AppDataHandlerClassMandatory"); Validator.ThrowArgumentExceptionIf( applicationSpecificHandlerClass.BaseType.Name != "ApplicationSpecific", "applicationSpecificHandlerClass", "AppDataHandlerNotApplicationSpecific"); Dictionary<string, HealthRecordItemTypeHandler> handlerDictionary = null; if (_appSpecificHandlers.ContainsKey(applicationId)) { handlerDictionary = _appSpecificHandlers[applicationId]; if (handlerDictionary.ContainsKey(subtypeTag) && !overwriteExisting) { throw new TypeHandlerAlreadyRegisteredException( ResourceRetriever.GetResourceString("AppDataHandlerAlreadyRegistered")); } } else { handlerDictionary = new Dictionary<string, HealthRecordItemTypeHandler>(); _appSpecificHandlers.Add(applicationId, handlerDictionary); } HealthRecordItemTypeHandler handler = new HealthRecordItemTypeHandler(applicationSpecificHandlerClass); handlerDictionary[subtypeTag] = handler; }
/// <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="Microsoft.Health.HealthRecordItemExtension"/>, /// 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="HealthRecordItemExtension"/>. /// </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, "itemExtensionClass", "ItemExtensionClassNull"); Validator.ThrowArgumentExceptionIf( !itemExtensionClass.IsSubclassOf(typeof(HealthRecordItemExtension)), "itemExtensionClass", "ThingExtensionClassNotThingExtension"); if (_extensionHandlers.ContainsKey(extensionSource) && !overwriteExisting) { throw new TypeHandlerAlreadyRegisteredException( ResourceRetriever.GetResourceString("ExtensionHandlerAlreadyRegistered")); } _extensionHandlers[extensionSource] = new HealthRecordItemTypeHandler(itemExtensionClass); }
/// <summary> /// Registers the default type handlers. /// </summary> /// private static Dictionary<Guid, HealthRecordItemTypeHandler> RegisterDefaultTypeHandlers( out Dictionary<string, HealthRecordItemTypeHandler> typeHandlersByClassName) { Dictionary<Guid, HealthRecordItemTypeHandler> typeHandlers = new Dictionary<Guid, HealthRecordItemTypeHandler>(); typeHandlersByClassName = new Dictionary<string, HealthRecordItemTypeHandler>( StringComparer.OrdinalIgnoreCase); foreach (DefaultTypeHandler typeHandler in _defaultTypeHandlers) { HealthRecordItemTypeHandler handler = new HealthRecordItemTypeHandler(typeHandler.TypeId, typeHandler.Type); typeHandlers.Add( typeHandler.TypeId, handler); typeHandlersByClassName.Add( typeHandler.TypeName, handler); } return typeHandlers; }