/// <summary>
        /// resolves an instance of this type
        /// </summary>
        /// <param name="Container">Container holding the registerd object</param>
        /// <param name="RegisteredObjectToBuild">Registered Object To Get The Instance Of</param>
        /// <returns>The resolved instance</returns>
        public object ResolveInstance(ToracDIContainer Container, RegisteredUnTypedObject RegisteredObjectToBuild)
        {
            //**so expression tree is slower if you are just running resolve a handful of times. You would need to get into the 10,000 resolves before it starts getting faster.
            //**since an asp.net mvc site will handle request after request the pool won't get recycled before 10,000. So we are going to build it for scalability with expression trees

            //instead of using activator, we are going to use an expression tree which is a ton faster.

            //so we are going to build a func that takes a params object[] and then we just set it to each item.

            //if we haven't already built the expression, then let's build and compile it now

            //singleton will only create it once, so singleton's will use the regular activator because it won't benefit of creating the object once. The cost
            //of the expression tree compile is too hight.

            //do we need to create an instance? This handles the derived per thread scoped object
            if (Instance != null)
            {
                //we have a valid instance, return it
                return Instance;
            }

            //go build the instance and store it
            Instance = Activator.CreateInstance(RegisteredObjectToBuild.ConcreteType, RegisteredObjectToBuild.ResolveConstructorParametersLazy(Container).ToArray());

            //now return the object we created. Don't return the instance which could be a derived typed
            return Instance;
        }
        /// <summary>
        /// resolves an instance of this type
        /// </summary>
        /// <param name="Container">Container holding the registerd object</param>
        /// <param name="RegisteredObjectToBuild">Registered Object To Get The Instance Of</param>
        /// <returns>The resolved instance</returns>
        public object ResolveInstance(ToracDIContainer Container, RegisteredUnTypedObject RegisteredObjectToBuild)
        {
            //if we have a valid object and its still alive then return it
            if (Instance == null || !Instance.IsAlive)
            {
                //at this point we don't have a valid object, we need to create it and put it in the property
                Instance = new WeakReference(CachedActivator.Invoke(RegisteredObjectToBuild.ResolveConstructorParametersLazy(Container).ToArray()));
            }

            //now just return the instance's target.
            return Instance.Target;
        }
        /// <summary>
        /// resolves an instance of this type
        /// </summary>
        /// <param name="Container">Container holding the registerd object</param>
        /// <param name="RegisteredObjectToBuild">Registered Object To Get The Instance Of</param>
        /// <returns>The resolved instance</returns>
        public object ResolveInstance(ToracDIContainer Container, RegisteredUnTypedObject RegisteredObjectToBuild)
        {
            //use the activator and go create the instance
            //return Activator.CreateInstance(RegisteredObjectToBuild.ConcreteType, ConstructorParameters);

            //**so expression tree is slower if you are just running resolve a handful of times. You would need to get into the 10,000 resolves before it starts getting faster.
            //**since an asp.net mvc site will handle request after request the pool won't get recycled before 10,000. So we are going to build it for scalability with expression trees

            //instead of using activator, we are going to use an expression tree which is a ton faster.

            //so we are going to build a func that takes a params object[] and then we just set it to each item.

            //if we haven't already built the expression, then let's build and compile it now

            //transients will benefit from the expression tree. singleton will only create it once, so singleton's will use the regular activator

            //we have the expression, so let's go invoke it and return the results
            return CachedActivator.Invoke(RegisteredObjectToBuild.ResolveConstructorParametersLazy(Container).ToArray());
        }