private static IEntityMetaData FromEdmx(IObjectContextAdapter contextAdapter, Type entityType)
            {
                List<SchemaInfo> schemas = new List<SchemaInfo>();

                MetadataWorkspace mw = contextAdapter.ObjectContext.MetadataWorkspace;

                EntityType et = mw.GetItems<EntityType>(DataSpace.CSpace).FirstOrDefault(e => String.Equals(e.Name, entityType.Name));
                if (null != et)
                {
                    foreach (EdmProperty edmProperty in et.Properties)
                    {
                        SchemaInfo schema = new SchemaInfo(edmProperty.Name);
                        schema.DataType = Type.GetType("System." + edmProperty.TypeUsage.EdmType.Name);

                        ReadOnlyMetadataCollection<Facet> facets = edmProperty.TypeUsage.Facets;
                        Facet facet;
                        if (facets.TryGetValue("Nullable", true, out facet))
                        {
                            schema.IsNullable = (bool)facet.Value;
                        }
                        if (facets.TryGetValue("MaxLength", true, out facet))
                        {
                            schema.MaxLength = (int)facet.Value;
                        }

                        schemas.Add(schema);
                    }

                    foreach (EdmMember keyInfo in et.KeyMembers)
                    {
                        schemas.First(s => s.ColumnName == keyInfo.Name).IsKey = true;
                    }

                    if (et.KeyMembers.Count == 1)
                    {
                        SchemaInfo key = schemas.First(s => s.IsKey);
                        if (key.DataType != CachedTypes.Guid)
                            key.DatabaseGeneratedOption = Data.StoreGeneratedPattern.Identity;
                    }

                    if (schemas.Count != 0)
                    {
                        EntityMetaData ret = new EntityMetaData(entityType, entityType.Name);
                        foreach (SchemaInfo schema in schemas)
                        {
                            ret.Add(schema, entityType.GetProperty(schema.ColumnName));
                        }
                        return ret;
                    }
                }

                return null;
            }
        public IEntityMetaData CreateEntityMetaData(Type entityType)
        {
            lock (syncRoot)
            {
                Type derivedType = this.GetType();
                Dictionary<Type, IEntityMetaData> tempCache;
                if (!_cache.TryGetValue(derivedType, out tempCache))
                {
                    tempCache = new Dictionary<Type, IEntityMetaData>();
                   _cache.Add(derivedType, tempCache);
                }

                IEntityMetaData metaData;
                if (!tempCache.TryGetValue(entityType, out metaData))
                {
                    int order = 0;
                    EntityMetaData temp = new EntityMetaData(entityType);
                    foreach (PropertyInfo pi in entityType.GetProperties(BindingFlags.Public | BindingFlags.Instance))
                    {
                        ++order;
                        SchemaInfo schema = this.FromPropertyInfo(pi);
                        if (null == schema) //NotMapped.
                            continue;

                        schema.Order = order; //Order parametere isimlarine ardışıklık için çok önemli. Oyüzden base de atamasını yaptık.
                        schema.Lock();
                        temp.Add(schema, pi);
                    }

                    this.SetExtendedMetaData(temp);

                    tempCache.Add(entityType, temp);
                    metaData = temp;
                }

                return metaData;
            }
        }