protected virtual ISourceProxy CreateProxy(object source, IPathNode node)
        {
            IProxyType proxyType = source.GetType().AsProxy();

            if (node is IndexedNode)
            {
                if (!(source is ICollection))
                {
                    throw new ProxyException("Type \"{0}\" is not a collection and cannot be accessed by index \"{1}\".", proxyType.Type.Name, node.ToString());
                }

                var itemInfo = proxyType.GetItem();
                if (itemInfo == null)
                {
                    throw new MissingMemberException(proxyType.Type.FullName, "Item");
                }

                var intIndexedNode = node as IntegerIndexedNode;
                if (intIndexedNode != null)
                {
                    return(new IntItemNodeProxy((ICollection)source, intIndexedNode.Value, itemInfo));
                }

                var stringIndexedNode = node as StringIndexedNode;
                if (stringIndexedNode != null)
                {
                    return(new StringItemNodeProxy((ICollection)source, stringIndexedNode.Value, itemInfo));
                }

                return(null);
            }

            var memberNode = node as MemberNode;

            if (memberNode == null)
            {
                return(null);
            }

            var memberInfo = memberNode.MemberInfo;

            if (memberInfo == null)
            {
                memberInfo = source.GetType().FindFirstMemberInfo(memberNode.Name);
            }

            if (memberInfo == null || memberInfo.IsStatic())
            {
                throw new MissingMemberException(proxyType.Type.FullName, memberNode.Name);
            }

            var propertyInfo = memberInfo as PropertyInfo;

            if (propertyInfo != null)
            {
                IProxyPropertyInfo proxyPropertyInfo = propertyInfo.AsProxy();
                var valueType = proxyPropertyInfo.ValueType;
                if (typeof(IObservableProperty).IsAssignableFrom(valueType))
                {
                    object observableValue = proxyPropertyInfo.GetValue(source);
                    if (observableValue == null)
                    {
                        return(null);
                    }

                    return(new ObservableNodeProxy(source, (IObservableProperty)observableValue));
                }
                else if (typeof(IInteractionRequest).IsAssignableFrom(valueType))
                {
                    object request = proxyPropertyInfo.GetValue(source);
                    if (request == null)
                    {
                        return(null);
                    }

                    return(new InteractionNodeProxy(source, (IInteractionRequest)request));
                }
                else
                {
                    return(new PropertyNodeProxy(source, proxyPropertyInfo));
                }
            }

            var fieldInfo = memberInfo as FieldInfo;

            if (fieldInfo != null)
            {
                IProxyFieldInfo proxyFieldInfo = fieldInfo.AsProxy();
                var             valueType      = proxyFieldInfo.ValueType;
                if (typeof(IObservableProperty).IsAssignableFrom(valueType))
                {
                    object observableValue = proxyFieldInfo.GetValue(source);
                    if (observableValue == null)
                    {
                        return(null);
                    }

                    return(new ObservableNodeProxy(source, (IObservableProperty)observableValue));
                }
                else if (typeof(IInteractionRequest).IsAssignableFrom(valueType))
                {
                    object request = proxyFieldInfo.GetValue(source);
                    if (request == null)
                    {
                        return(null);
                    }

                    return(new InteractionNodeProxy(source, (IInteractionRequest)request));
                }
                else
                {
                    return(new FieldNodeProxy(source, proxyFieldInfo));
                }
            }

            var methodInfo = memberInfo as MethodInfo;

            if (methodInfo != null && methodInfo.ReturnType.Equals(typeof(void)))
            {
                return(new MethodNodeProxy(source, methodInfo.AsProxy()));
            }

            var eventInfo = memberInfo as EventInfo;

            if (eventInfo != null)
            {
                return(new EventNodeProxy(source, eventInfo.AsProxy()));
            }

            return(null);
        }