private void StartReceiving() { Task.Run(() => { foreach (var msg in Mailbox.GetConsumingEnumerable()) { if (!TypeHandlers.ContainsKey(msg.GetType())) { System.UnhandledMessages.Tell(new ActorSystem.UnhandledMessage() { Message = msg }); continue; } try { TypeHandlers[msg.GetType()](msg); } catch (System.Exception ex) { Parent.Tell(ex); } } }); }
/// <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]; }
/// <summary> /// Process a constant expression, if possible. Some forms of constant expressions /// are actually just stubs for dealing with something that needs to be injected into /// the process. /// </summary> /// <param name="expression"></param> /// <returns></returns> protected override Expression VisitConstant(ConstantExpression expression) { if (TypeHandlers == null) { throw new InvalidOperationException("Can't visit a constant expression unless the typehandlers have been initalized"); } return(TypeHandlers.ProcessConstantReferenceAsExpression(expression, MEFContainer)); }
public SerializationContext() { DateTimeOptions = new DateTimeOptions(); EnumOptions = new EnumOptions(); ArrayOptions = new ArrayOptions(); MapOptions = new MapOptions(); JsonOptions = new JsonOptions(); TypeHandlers = new TypeHandlers(this); }
/// <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); }
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); }
/// <summary> /// Some method is being called. Offer plug-ins a chance to transform this method call. /// </summary> /// <param name="expression"></param> /// <returns></returns> protected override Expression VisitMethodCall(MethodCallExpression expression) { // // Give the various type handlers a chance to alter the expression call if they want. // var expr = TypeHandlers.ProcessMethodCall(expression, GeneratedCode, CodeContext, MEFContainer); // // If it is still an expression call, then we need to allow the arguments to transform. // if (expr is MethodCallExpression) { var mc = expr as MethodCallExpression; var transformedArgs = from a in mc.Arguments select a.Resolve(GeneratedCode, CodeContext, MEFContainer); expr = Expression.Call(mc.Object, mc.Method, transformedArgs); } return(expr); }
public SmartSqlBuilder AddTypeHandler(TypeHandler typeHandler) { TypeHandlers.Add(typeHandler); return(this); }
internal static bool HasTypeHandler(Type type) => TypeHandlers.ContainsKey(type);