[AttributeUsage(AttributeTargets.Field)]
  class SerializableField : Attribute {
    
  }

 [AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
  class SerializableField : Attribute {
    
  }

  [SerializableField]
    private int blub = 0;

    [SerializableField]
    private String bla = String.Empty;

    private Decimal nonSerializable = 0.0m;

using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.Serialization.Formatters.Binary;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using Util;
using System.Runtime.Serialization;
using System.Reflection;

namespace Util {
  /// <summary>
  /// Handles serialization issues
  /// </summary>
  public class SerializationUtil {
    private static readonly String PREFIX_SERIALIZABLE_VALUES_FIELD = "F_";
    private static readonly String PREFIX_SERIALIZABLE_VALUES_PROPERTY = "P_";
    private static readonly BindingFlags SERIALIZABLE_VALUES_BINDINGFLAGS = 
      BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static;

    /// <summary>
    /// Sets all fields and properties which are flagged with the 
    /// <see cref="Util.SerializableValue"/> attribute on the passed instance
    /// </summary>
    /// <param name="instance">The instance</param>
    /// <param name="serializedValues"></param>
    public static void SetSerializableValues(Object instance, Dictionary<String, Object> serializedValues) {
      try {
        // Check instance
        if(instance == null) {
          throw new ArgumentException("Parameter instance was passed null");
        }

        // Check serialized values
        if(serializedValues == null) {
          throw new ArgumentException("Parameter serializedValues was passed null");
        }

        foreach(String key in serializedValues.Keys) {
          String removePrefix = String.Empty;

          if(key.StartsWith(SerializationUtil.PREFIX_SERIALIZABLE_VALUES_FIELD)) {
            String fieldName = StringUtil.ReplaceEmpty(key, 
              SerializationUtil.PREFIX_SERIALIZABLE_VALUES_FIELD);

            // Get field info
            FieldInfo fieldInfo = instance.GetType().GetField(fieldName,
              SerializationUtil.SERIALIZABLE_VALUES_BINDINGFLAGS | BindingFlags.GetField);

            // Set value
            fieldInfo.SetValue(instance, serializedValues[key]);
          }
          else if(key.StartsWith(SerializationUtil.PREFIX_SERIALIZABLE_VALUES_PROPERTY)) {
            String fieldName = StringUtil.ReplaceEmpty(key,
            SerializationUtil.PREFIX_SERIALIZABLE_VALUES_PROPERTY);

            // Get property info
            PropertyInfo propertyInfo = instance.GetType().GetProperty(fieldName,
              SerializationUtil.SERIALIZABLE_VALUES_BINDINGFLAGS | BindingFlags.GetProperty);

            // Set value
            propertyInfo.SetValue(instance, serializedValues[key], null);
          }
        }
      }
      catch {
        throw;
      }
    }

    /// <summary>
    /// Gets all instance field and property values for the passed instance
    /// which has been flagged with the attribute <see cref="Util.SerializableValue"/>
    /// </summary>
    /// <param name="instance">The instance</param>
    /// <returns>Dict</returns>
    public static Dictionary<String, Object> GetSerializableValues(Object instance) {
      Dictionary<String, Object> serializableValues = null;

      try {
        if(instance != null) {
          // Get all field infos
          FieldInfo[] fieldInfos = instance.GetType().GetFields(
            SerializationUtil.SERIALIZABLE_VALUES_BINDINGFLAGS | BindingFlags.GetField);

          if(fieldInfos != null) {
            foreach(FieldInfo fieldInfo in fieldInfos) {
              Object[] customAttributes = fieldInfo.GetCustomAttributes(true);

              if(customAttributes != null) {
                foreach(Object customAttribute in customAttributes) {
                  if(customAttribute.GetType().Equals(typeof(SerializableValue))) {
                    // Add to dictionary
                    if(serializableValues == null) {
                      serializableValues = new Dictionary<String, Object>();
                    }

                    serializableValues.Add(SerializationUtil.PREFIX_SERIALIZABLE_VALUES_FIELD +
                      fieldInfo.Name, fieldInfo.GetValue(instance));
                  }
                }
              }
            }
          }

          // Get all property infos
          PropertyInfo[] propertyInfos = instance.GetType().GetProperties(
            SerializationUtil.SERIALIZABLE_VALUES_BINDINGFLAGS | BindingFlags.GetProperty);

          if(propertyInfos != null) {
            foreach(PropertyInfo propertyInfo in propertyInfos) {
              Object[] customAttributes = propertyInfo.GetCustomAttributes(true);

              if(customAttributes != null) {
                foreach(Object customAttribute in customAttributes) {
                  if(customAttribute.GetType().Equals(typeof(SerializableValue))) {
                    // Add to dictionary
                    if(serializableValues == null) {
                      serializableValues = new Dictionary<String, Object>();
                    }

                    serializableValues.Add(SerializationUtil.PREFIX_SERIALIZABLE_VALUES_PROPERTY +
                      propertyInfo.Name, propertyInfo.GetValue(instance, null));
                  }
                }
              }
            }
          }
        }
      }
      catch {
        throw;
      }

      return serializableValues;
    }
  }
}