public void Can_Raise_PropertyChanged_In_TransientObject()
        {
            var parent = DynamicProxyTool.CreateEditablePropertyChanged <Parent>();

            VerifyNotifyPropertyChanged(parent);
            VerifyEditableObject(parent);
        }
        public void Can_Raise_PropertyChanged_In_TransientObject_With_Mapping()
        {
            var parent = parentsInDB[0].MapProperty(() => DynamicProxyTool.CreateEditablePropertyChanged <Parent>(),
                                                    MapPropertyOptions.Safety);

            VerifyNotifyPropertyChanged(parent);
            VerifyEditableObject(parent);
        }
 public void MapObjectsAsParallel_To_Proxy_With_CustomMap()
 {
     var targets =
         SourceDatas
         .MapObjectsAsParallel <SourceData, TargetData>(() => DynamicProxyTool.CreateNotifyPropertyChanged <TargetData>(),
                                                        (s, t) => t.OtherDataOnly = s.DataOnly)
         .ToList();
 }
Example #4
0
        /// <summary>
        /// IoC를 통해 컴포넌트를 Resolve하고, <see cref="INotifyPropertyChanged"/>를 가지는 Proxy로 생성하여 반환합니다.
        /// NOTE: 원본 클래스의 속성이나 메소드가 virtual 이어야만 proxy의 interceptor가 수행합니다.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="componentId"></param>
        /// <param name="additionalInterfacesInterfaceToProxy"></param>
        /// <param name="interceptors"></param>
        /// <returns></returns>
        public static T CreateProxy <T>(string componentId, Type[] additionalInterfacesInterfaceToProxy,
                                        params IInterceptor[] interceptors) where T : class
        {
            if (IsDebugEnabled)
            {
                log.Debug("ComponentId[{0}]의 형식[{1}]에  INotifyPropertyChanged가 구현된 Proxy를 생성합니다...", componentId,
                          typeof(T).AssemblyQualifiedName);
            }

            return((T)DynamicProxyTool.Create(() => IoC.Resolve <T>(componentId), additionalInterfacesInterfaceToProxy, interceptors));
        }
Example #5
0
        /// <summary>
        /// IoC를 통해 컴포넌트를 Resolve하고, <see cref="INotifyPropertyChanged"/>를 가지는 Proxy로 생성하여 반환합니다.
        /// NOTE: 원본 클래스의 속성이나 메소드가 virtual 이어야만 proxy의 interceptor가 수행합니다.
        /// </summary>
        /// <param name="componentType"></param>
        /// <param name="additionalInterfacesInterfaceToProxy"></param>
        /// <param name="interceptors"></param>
        /// <returns></returns>
        public static object CreateProxy(Type componentType, Type[] additionalInterfacesInterfaceToProxy,
                                         params IInterceptor[] interceptors)
        {
            componentType.ShouldNotBeNull("componentType");

            if (IsDebugEnabled)
            {
                log.Debug("Component 형식[{0}]에  INotifyPropertyChanged가 구현된 Proxy를 생성합니다...", componentType.AssemblyQualifiedName);
            }


            return(DynamicProxyTool.Create(() => IoC.Resolve(componentType), additionalInterfacesInterfaceToProxy, interceptors));
        }
Example #6
0
        public void MapObjectsAsParallel_To_Proxy_With_CustomMap_Options()
        {
            var targets =
                SourceDatas
                .MapObjectsAsParallel <SourceData, TargetData>(() => DynamicProxyTool.CreateNotifyPropertyChanged <TargetData>(),
                                                               (s, t) => t.OtherDataOnly = s.DataOnly)
                .ToList();

            Assert.AreEqual(SourceDatas.Count, targets.Count);
            for (int i = 0; i < SourceDatas.Count; i++)
            {
                var source = SourceDatas[i];
                var target = targets[i];

                Assert.AreEqual(source.Id, target.Id);
                Assert.AreEqual(source.Name, target.Name);
                Assert.AreEqual(source.Guid, target.Guid);
                Assert.AreEqual(source.CreatedDate, target.CreatedDate);
                Assert.AreEqual(source.ElapsedTimeSpan, target.ElapsedTimeSpan);
            }
        }
 /// <summary>
 /// NOTE: Proxy 생성 시 꼭 Type을 이용하여 Proxy를 생성해야 제대로 됩니다!!! Target Instance 으로 Proxy를 생성하면 예외가 발생합니다.
 /// </summary>
 /// <param name="entityType"></param>
 /// <returns></returns>
 protected override object CreateProxy(Type entityType)
 {
     return(DynamicProxyTool.CreateNotifyPropertyChanged(entityType));
 }
Example #8
0
 /// <summary>
 /// NOTE: Proxy 생성 시 꼭 Type을 이용하여 Proxy를 생성해야 제대로 됩니다!!! Target Instance 으로 Proxy를 생성하면 예외가 발생합니다.
 /// </summary>
 /// <param name="entityType"></param>
 /// <returns></returns>
 protected override object CreateProxy(Type entityType)
 {
     return(DynamicProxyTool.CreateEditableObject(entityType));
 }
Example #9
0
 /// <summary>
 /// IoC를 통해 컴포넌트를 Resolve하고, <see cref="INotifyPropertyChanged"/>를 가지는 Proxy로 생성하여 반환합니다.
 /// NOTE: 원본 클래스의 속성이나 메소드가 virtual 이어야만 proxy의 interceptor가 수행합니다.
 /// </summary>
 /// <param name="typeToProxy"></param>
 /// <returns></returns>
 public static object CreateNotifyPropertyChangedProxy(Type typeToProxy)
 {
     return(DynamicProxyTool.CreateNotifyPropertyChanged(() => IoC.Resolve(typeToProxy)));
 }
Example #10
0
 /// <summary>
 /// IoC를 통해 컴포넌트를 Resolve하고, <see cref="INotifyPropertyChanged"/>를 가지는 Proxy로 생성하여 반환합니다.
 /// NOTE: 원본 클래스의 속성이나 메소드가 virtual 이어야만 proxy의 interceptor가 수행합니다.
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="componentId"></param>
 /// <returns></returns>
 public static T CreateNotifyPropertyChangedProxy <T>(string componentId)
 {
     componentId.ShouldNotBeEmpty("componentId");
     return((T)DynamicProxyTool.CreateNotifyPropertyChanged(() => IoC.Resolve <T>(componentId)));
 }
Example #11
0
        // private static readonly ProxyGenerator _proxyGenerator = new ProxyGenerator();

        /// <summary>
        /// IoC를 통해 컴포넌트를 Resolve하고, <see cref="INotifyPropertyChanged"/>를 가지는 Proxy로 생성하여 반환합니다.
        /// NOTE: 원본 클래스의 속성이나 메소드가 virtual 이어야만 proxy의 interceptor가 수행합니다.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public static T CreateNotifyPropertyChangedProxy <T>()
        {
            return((T)DynamicProxyTool.CreateNotifyPropertyChanged(() => IoC.Resolve <T>()));
        }