コード例 #1
0
        /// <summary>
        /// Gets all of the members of the given type marked as being a keyvalue
        /// </summary>
        /// <param name="type"></param>
        /// <param name="metaData"></param>
        /// <returns></returns>
        private static IReadOnlyDictionary <string, IMemberAccessor> GetKeyValueAccessorsForType(Type type, ClassMetaData metaData)
        {
            //Use case insensitive comparison to match the engine
            var keyValues = new Dictionary <string, IMemberAccessor>(StringComparer.OrdinalIgnoreCase);

            VisitAccessibleMembers <KeyValueAttribute>(type, (kv, info) =>
            {
                var name = kv.KeyName ?? info.Name;

                if (!string.IsNullOrWhiteSpace(name))
                {
                    var accessor = metaData.GetAccessor(info);

                    if (!keyValues.ContainsKey(name))
                    {
                        keyValues.Add(name, accessor);
                    }
                    else
                    {
                        //TODO: consider allowing derived keyvalues to override base?
                        Log.Message($"Warning: Cannot consider member {type.FullName}.{info.Name} for keyvalue usage because another keyvalue with name \"{name}\" already exists");
                    }
                }
                else
                {
                    Log.Message($"Warning: Cannot consider member {type.FullName}.{info.Name} for keyvalue usage because it has an invalid name \"{name}\"");
                }
            }
                                                       );

            return(keyValues);
        }
コード例 #2
0
        /// <summary>
        /// Gets all of the members of the given type marked as needing to be persisted
        /// </summary>
        /// <param name="type"></param>
        /// <param name="metaData"></param>
        /// <returns></returns>
        private static IReadOnlyList <IMemberAccessor> GetPersistAccessorsForType(Type type, ClassMetaData metaData)
        {
            //Use case insensitive comparison to match the engine
            var persistedMembers = new List <IMemberAccessor>();

            VisitAccessibleMembers <PersistAttribute>(type, (_, info) =>
            {
                var accessor = metaData.GetAccessor(info);

                if (accessor.CanRead && accessor.CanWrite)
                {
                    persistedMembers.Add(accessor);
                }
                else
                {
                    var messageBuilder = new StringBuilder();

                    messageBuilder.Append("Warning: cannot persist member ")
                    .Append(type.FullName)
                    .Append(".")
                    .Append(accessor.Info.Name)
                    .Append(" because it is not ");

                    if (!accessor.CanRead)
                    {
                        messageBuilder.Append("readable ");

                        if (!accessor.CanWrite)
                        {
                            messageBuilder.Append(" and not");
                        }
                    }

                    if (!accessor.CanWrite)
                    {
                        messageBuilder.Append("writable");
                    }

                    Log.Message(messageBuilder.ToString());
                }
            }
                                                      );

            return(persistedMembers);
        }