Пример #1
0
        public void PropertyValuesEqual_checks_value_equality_for_value_types_and_reference_equality_for_reference_types()
        {
            Equality_tests(DbHelpers.PropertyValuesEqual);

            Assert.False(DbHelpers.PropertyValuesEqual(new ExecutionStrategyKey("foo", "bar"), new ExecutionStrategyKey("foo", "bar")));
        }
        // <summary>
        // Creates the underlying <see cref="DbConnection" /> (which may actually be an <see cref="EntityConnection" />)
        // if it does not already exist.
        // </summary>
        private void Initialize()
        {
            if (UnderlyingConnection == null)
            {
                Debug.Assert(AppConfig != null);

                string name;
                if (_connectionInfo != null)
                {
                    var connection = _connectionInfo.GetConnectionString(AppConfig);
                    InitializeFromConnectionStringSetting(connection);

                    _connectionStringOrigin = DbConnectionStringOrigin.DbContextInfo;
                    _connectionStringName   = connection.Name;
                }
                // If the name or connection string is a simple name or is in the form "name=xyz" then use
                // that name to try to load from the app/web config file.
                else if (!DbHelpers.TryGetConnectionName(_nameOrConnectionString, out name) ||
                         !TryInitializeFromAppConfig(name, AppConfig))
                {
                    // If the connection string is of the form name=, but the name was not found in the config file
                    // then always throw since we always interpret name= to mean find in the config file only.
                    if (name != null &&
                        DbHelpers.TreatAsConnectionString(_nameOrConnectionString))
                    {
                        throw Error.DbContext_ConnectionStringNotFound(name);
                    }

                    // If the name or connection string is a full EF connection string, then create an EntityConnection from it.
                    if (DbHelpers.IsFullEFConnectionString(_nameOrConnectionString))
                    {
                        UnderlyingConnection = new EntityConnection(_nameOrConnectionString);
                    }
                    else
                    {
                        if (base.ProviderName != null)
                        {
                            CreateConnectionFromProviderName(base.ProviderName);
                        }
                        else
                        {
                            // Otherwise figure out the connection factory to use (either the default,
                            // the one set in code, or one provided by DbContextInfo via the AppSettings property
                            UnderlyingConnection = DbConfiguration.DependencyResolver.GetService <IDbConnectionFactory>()
                                                   .CreateConnection(name ?? _nameOrConnectionString);

                            if (UnderlyingConnection == null)
                            {
                                throw Error.DbContext_ConnectionFactoryReturnedNullConnection();
                            }
                        }
                    }

                    if (name != null)
                    {
                        _connectionStringOrigin = DbConnectionStringOrigin.Convention;
                        _connectionStringName   = name;
                    }
                    else
                    {
                        _connectionStringOrigin = DbConnectionStringOrigin.UserCode;
                    }
                }

                OnConnectionInitialized();
            }

            Debug.Assert(UnderlyingConnection != null, "Connection should have been initialized by some mechanism.");
        }
Пример #3
0
        public void KeyValuesEqual_checks_value_equality_for_value_types_and_Equals_implementation_for_reference_types()
        {
            Equality_tests(DbHelpers.KeyValuesEqual);

            Assert.True(DbHelpers.KeyValuesEqual(new ExecutionStrategyKey("foo", "bar"), new ExecutionStrategyKey("foo", "bar")));
        }
Пример #4
0
        // <summary>
        // Validates that the given name is a property of the declaring type (either on the CLR type or in the EDM)
        // and that it is a complex or scalar property rather than a nav property and then returns metadata about
        // the property.
        // </summary>
        // <param name="internalContext"> The internal context. </param>
        // <param name="declaringType"> The type that the property is declared on. </param>
        // <param name="requestedType"> The type of property requested, which may be 'object' if any type can be accepted. </param>
        // <param name="propertyName"> Name of the property. </param>
        // <returns> Metadata about the property, or null if the property does not exist or is a navigation property. </returns>
        public static PropertyEntryMetadata ValidateNameAndGetMetadata(
            InternalContext internalContext, Type declaringType, Type requestedType, string propertyName)
        {
            DebugCheck.NotNull(internalContext);
            DebugCheck.NotNull(declaringType);
            DebugCheck.NotNull(requestedType);
            DebugCheck.NotEmpty(propertyName);

            Type propertyType;

            DbHelpers.GetPropertyTypes(declaringType).TryGetValue(propertyName, out propertyType);

            var metadataWorkspace = internalContext.ObjectContext.MetadataWorkspace;
            var edmType           = metadataWorkspace.GetItem <StructuralType>(declaringType.FullNameWithNesting(), DataSpace.OSpace);

            var isMapped  = false;
            var isComplex = false;

            EdmMember member;

            edmType.Members.TryGetValue(propertyName, false, out member);
            if (member != null)
            {
                // If the property is in the model, then it must be a scalar or complex property, not a nav prop
                var edmProperty = member as EdmProperty;
                if (edmProperty == null)
                {
                    return(null);
                }

                if (propertyType == null)
                {
                    var asPrimitive = edmProperty.TypeUsage.EdmType as PrimitiveType;
                    if (asPrimitive != null)
                    {
                        propertyType = asPrimitive.ClrEquivalentType;
                    }
                    else
                    {
                        Debug.Assert(
                            edmProperty.TypeUsage.EdmType is StructuralType, "Expected a structural type if property type is not primitive.");

                        var objectItemCollection =
                            (ObjectItemCollection)metadataWorkspace.GetItemCollection(DataSpace.OSpace);
                        propertyType = objectItemCollection.GetClrType((StructuralType)edmProperty.TypeUsage.EdmType);
                    }
                }

                isMapped  = true;
                isComplex = edmProperty.TypeUsage.EdmType.BuiltInTypeKind == BuiltInTypeKind.ComplexType;
            }
            else
            {
                // If the prop is not in the model, then it must have a getter or a setter
                var propertyGetters = DbHelpers.GetPropertyGetters(declaringType);
                var propertySetters = DbHelpers.GetPropertySetters(declaringType);
                if (!(propertyGetters.ContainsKey(propertyName) || propertySetters.ContainsKey(propertyName)))
                {
                    return(null);
                }

                Debug.Assert(propertyType != null, "If the property has a getter or setter, then it must exist and have a type.");
            }

            if (!requestedType.IsAssignableFrom(propertyType))
            {
                throw Error.DbEntityEntry_WrongGenericForProp(
                          propertyName, declaringType.Name, requestedType.Name, propertyType.Name);
            }

            return(new PropertyEntryMetadata(declaringType, propertyType, propertyName, isMapped, isComplex));
        }
Пример #5
0
 public static string GetPropertyPath(InternalMemberEntry property)
 {
     return(string.Join(".", DbHelpers.GetPropertyPathSegments(property).Reverse <string>()));
 }
Пример #6
0
        public static bool TryParsePath(Expression expression, out string path)
        {
            path = (string)null;
            Expression           expression1          = expression.RemoveConvert();
            MemberExpression     memberExpression     = expression1 as MemberExpression;
            MethodCallExpression methodCallExpression = expression1 as MethodCallExpression;

            if (memberExpression != null)
            {
                string name = memberExpression.Member.Name;
                string path1;
                if (!DbHelpers.TryParsePath(memberExpression.Expression, out path1))
                {
                    return(false);
                }
                path = path1 == null ? name : path1 + "." + name;
            }
            else if (methodCallExpression != null)
            {
                string path1;
                if (methodCallExpression.Method.Name == "Select" && methodCallExpression.Arguments.Count == 2 && (DbHelpers.TryParsePath(methodCallExpression.Arguments[0], out path1) && path1 != null))
                {
                    LambdaExpression lambdaExpression = methodCallExpression.Arguments[1] as LambdaExpression;
                    string           path2;
                    if (lambdaExpression != null && DbHelpers.TryParsePath(lambdaExpression.Body, out path2) && path2 != null)
                    {
                        path = path1 + "." + path2;
                        return(true);
                    }
                }
                return(false);
            }
            return(true);
        }
Пример #7
0
        private ObjectQuery <DbDataRecord> GetDatabaseValuesQuery()
        {
            StringBuilder queryBuilder = new StringBuilder();

            queryBuilder.Append("SELECT ");
            this.AppendEntitySqlRow(queryBuilder, "X", this.OriginalValues);
            string str1 = string.Format((IFormatProvider)CultureInfo.InvariantCulture, "{0}.{1}", (object)DbHelpers.QuoteIdentifier(this._stateEntry.EntitySet.EntityContainer.Name), (object)DbHelpers.QuoteIdentifier(this._stateEntry.EntitySet.Name));
            string str2 = string.Format((IFormatProvider)CultureInfo.InvariantCulture, "{0}.{1}", (object)DbHelpers.QuoteIdentifier(this.EntityType.NestingNamespace()), (object)DbHelpers.QuoteIdentifier(this.EntityType.Name));

            queryBuilder.AppendFormat((IFormatProvider)CultureInfo.InvariantCulture, " FROM (SELECT VALUE TREAT (Y AS {0}) FROM {1} AS Y) AS X WHERE ", (object)str2, (object)str1);
            EntityKeyMember[] entityKeyValues      = this._stateEntry.EntityKey.EntityKeyValues;
            ObjectParameter[] objectParameterArray = new ObjectParameter[entityKeyValues.Length];
            for (int index = 0; index < entityKeyValues.Length; ++index)
            {
                if (index > 0)
                {
                    queryBuilder.Append(" AND ");
                }
                string name = string.Format((IFormatProvider)CultureInfo.InvariantCulture, "p{0}", (object)index.ToString((IFormatProvider)CultureInfo.InvariantCulture));
                queryBuilder.AppendFormat((IFormatProvider)CultureInfo.InvariantCulture, "X.{0} = @{1}", (object)DbHelpers.QuoteIdentifier(entityKeyValues[index].Key), (object)name);
                objectParameterArray[index] = new ObjectParameter(name, entityKeyValues[index].Value);
            }
            return(this._internalContext.ObjectContext.CreateQuery <DbDataRecord>(queryBuilder.ToString(), objectParameterArray));
        }