2011년 10월 12일 수요일

Newtonsoft.Json.Net.dll 을 사용하여 직렬화/역직렬화하기

 
객체를 Json 형식으로 직렬화/ 역직렬화를 수행하여, 다른 형식의 수형으로 매핑을 수행합니다.
보통의 경우 Binary 방식의 경우는 객체가 SerializableAttribute가 있어야 하고, Xml 방식은 성능이 안나옵니다.
이럴 때, Json 또는 Bson 방식을 사용하게 되면 상당히 유리합니다.
 
   1: using System;
   2: using Newtonsoft.Json;
   3:  
   4: namespace RCL.Core
   5: {
   6:     /// <summary>
   7:     /// JSON 포맷으로 객체 Mapping을 수행합니다.
   8:     /// </summary>
   9:     public static partial class JsonUtil
  10:     {
  11:         /// <summary>
  12:         /// 객체를 JSON 직렬화/역직렬화를 통해, T 수형의 인스턴스를 빌드합니다.
  13:         /// </summary>
  14:         /// <typeparam name="T">대상 수형</typeparam>
  15:         /// <param name="source">원본객체</param>
  16:         /// <returns>매핑된 T 수형의 객체</returns>
  17:         public static T Mapping<T>(object source)
  18:         {
  19:             return Mapping<T>(source, DefaultJsonSerializerSettings);
  20:         }
  21:  
  22:         /// <summary>
  23:         /// 객체를 JSON 직렬화/역직렬화를 통해, T 수형의 인스턴스를 빌드합니다.
  24:         /// </summary>
  25:         /// <typeparam name="T">대상 수형</typeparam>
  26:         /// <param name="source">원본객체</param>
  27:         /// <param name="serializerSettings">JSON 직렬화 설정 정보</param>
  28:         /// <returns>매핑된 T 수형의 객체</returns>
  29:         public static T Mapping<T>(object source, JsonSerializerSettings serializerSettings)
  30:         {
  31:             source.ShouldNotBeNull("source");
  32:  
  33:             T target;
  34:  
  35:             if(TryMapping(source, serializerSettings, out target))
  36:                 return target;
  37:  
  38:             return default(T);
  39:         }
  40:  
  41:         /// <summary>
  42:         ///  객체를 JSON 직렬화/역직렬화를 통해, T 수형의 인스턴스를 빌드합니다.
  43:         /// </summary>
  44:         /// <typeparam name="T">대상 수형</typeparam>
  45:         /// <param name="source">원본객체</param>
  46:         /// <param name="additionalMapping">부가 매핑 정보</param>
  47:         /// <returns>매핑된 T 수형의 객체</returns>
  48:         public static T Mapping<T>(object source, Action<object, T> additionalMapping)
  49:         {
  50:             source.ShouldNotBeNull("source");
  51:             var result = Mapping<T>(source);
  52:  
  53:             if(additionalMapping != null)
  54:             {
  55:                 additionalMapping(source, result);
  56:             }
  57:             return result;
  58:         }
  59:  
  60:         /// <summary>
  61:         /// 객체를 JSON 직렬화/역직렬화를 통해, <paramref name="targetType"/> 수형의 인스턴스를 빌드합니다.
  62:         /// </summary>
  63:         /// <param name="source">원본 객체</param>
  64:         /// <param name="targetType">대상 수형</param>
  65:         /// <returns>매핑된 대상 수형의 객체</returns>
  66:         public static object Mapping(object source, Type targetType)
  67:         {
  68:             return Mapping(source, targetType, DefaultJsonSerializerSettings);
  69:         }
  70:  
  71:         /// <summary>
  72:         /// 객체를 JSON 직렬화/역직렬화를 통해, <paramref name="targetType"/> 수형의 인스턴스를 빌드합니다.
  73:         /// </summary>
  74:         /// <param name="source">원본 객체</param>
  75:         /// <param name="targetType">대상 수형</param>
  76:         /// <param name="serializerSettings">JSON 직렬화 설정 정보</param>
  77:         /// <returns>매핑된 대상 수형의 객체</returns>
  78:         public static object Mapping(object source, Type targetType, JsonSerializerSettings serializerSettings)
  79:         {
  80:             source.ShouldNotBeNull("source");
  81:             targetType.ShouldNotBeNull("targetType");
  82:  
  83:             object target;
  84:  
  85:             if(TryMapping(source, targetType, serializerSettings, out target))
  86:                 return target;
  87:  
  88:             return null;
  89:         }
  90:  
  91:         /// <summary>
  92:         /// 원본 객체를 JSON 포맷으로 직렬화를 수행하고, 대상 형식으로 역직렬화를 수행합니다. 두 수형이 달라도 상관없습니다.
  93:         /// </summary>
  94:         /// <param name="source">원본 객체</param>
  95:         /// <param name="target">대상 객체</param>
  96:         /// <returns>Mapping 성공 여부</returns>
  97:         /// <see cref="ObjectMapper"/>
  98:         public static bool TryMapping<T>(object source, out T target)
  99:         {
 100:             return TryMapping<T>(source, DefaultJsonSerializerSettings, out target);
 101:         }
 102:  
 103:         /// <summary>
 104:         /// 원본 객체를 JSON 포맷으로 직렬화를 수행하고, 대상 형식으로 역직렬화를 수행합니다. 두 수형이 달라도 상관없습니다.
 105:         /// </summary>
 106:         /// <param name="source">원본 객체</param>
 107:         /// <param name="target">대상 객체</param>
 108:         /// <param name="serializerSettings">JSON 직렬화 설정 정보</param>
 109:         /// <returns>Mapping 성공 여부</returns>
 110:         /// <see cref="ObjectMapper"/>
 111:         public static bool TryMapping<T>(object source, JsonSerializerSettings serializerSettings, out T target)
 112:         {
 113:             if(source == null)
 114:             {
 115:                 target = default(T);
 116:                 return false;
 117:             }
 118:  
 119:             Type targetType = typeof(T);
 120:             target = default(T);
 121:             object targetObject;
 122:  
 123:             var result = TryMapping(source, targetType, serializerSettings, out targetObject);
 124:             if(result)
 125:                 target = (T)targetObject;
 126:  
 127:             return result;
 128:         }
 129:  
 130:         /// <summary>
 131:         /// 원본 객체를 JSON 포맷으로 직렬화를 수행하고, 대상 수형으로 역직렬화를 수행합니다. 두 수형이 달라도 상관없습니다.
 132:         /// </summary>
 133:         /// <param name="source">원본 객체</param>
 134:         /// <param name="targetType">대상 객체의 수형</param>
 135:         /// <param name="target">대상 객체</param>
 136:         /// <returns>Mapping 성공 여부</returns>
 137:         /// <see cref="ObjectMapper"/>
 138:         public static bool TryMapping(object source, Type targetType, out object target)
 139:         {
 140:             return TryMapping(source, targetType, DefaultJsonSerializerSettings, out target);
 141:         }
 142:  
 143:         /// <summary>
 144:         /// 원본 객체를 JSON 포맷으로 직렬화를 수행하고, 대상 수형으로 역직렬화를 수행합니다. 두 수형이 달라도 상관없습니다.
 145:         /// </summary>
 146:         /// <param name="source">원본 객체</param>
 147:         /// <param name="targetType">대상 객체의 수형</param>
 148:         /// <param name="serializerSettings">JSON 직렬화 설정 정보</param>
 149:         /// <param name="target">대상 객체</param>
 150:         /// <returns>Mapping 성공 여부</returns>
 151:         /// <see cref="ObjectMapper"/>
 152:         public static bool TryMapping(object source, Type targetType, JsonSerializerSettings serializerSettings, out object target)
 153:         {
 154:             var result = false;
 155:             target = null;
 156:  
 157:             try
 158:             {
 159:                 source.ShouldNotBeNull("source");
 160:                 targetType.ShouldNotBeNull("targetType");
 161:                 serializerSettings.ShouldNotBeNull("serializerSettings");
 162:  
 163:                 if(IsDebugEnabled)
 164:                 {
 165:                     log.Debug("원본 객체를 JSON 포맷으로 직렬화를 수행하고, 대상 수형[{0}]으로 역직렬화를 수행합니다.", targetType.FullName);
 166:                     log.Debug("source=[{0}], targetType=[{1}], serializerSettings=[{2}]", source, targetType, serializerSettings);
 167:                 }
 168:  
 169:                 var jsonText = SerializeAsText(source, serializerSettings);
 170:                 target = DeserializeFromText(jsonText, targetType, serializerSettings);
 171:  
 172:                 result = true;
 173:  
 174:                 if(IsDebugEnabled)
 175:                     log.Debug("원본 객체로부터 대상 객체로 매핑을 수행했습니다. target=[{0}]", target);
 176:             }
 177:             catch(Exception ex)
 178:             {
 179:                 if(log.IsWarnEnabled)
 180:                 {
 181:                     log.Warn("JSON 포맷을 이용한 객체 Mapping 작업에 실패했습니다.");
 182:                     log.Warn(ex);
 183:                 }
 184:             }
 185:             return result;
 186:         }
 187:     }
 188: }

댓글 없음: