Getting the database name from an Entity Framework Context

This seems like it should be so easy, but it took awhile to figure out.  Both methods below take an ObjectContext.  You can get that from a DbContext using ((IObjectContextAdapter)myDbContext).ObjectContext.

public static string ADOConnectionString( ObjectContext context )
{
    return ( (EntityConnection)context.Connection ).StoreConnection.ConnectionString;
}

/// This works regardless of how the connection string names the database ("initial catalog", "database", etc.).
public static string DatabaseName( ObjectContext context )
{
    return new SqlConnectionStringBuilder( ADOConnectionString( context ) ).InitialCatalog;
}

Querying an Entity Framework Model for Column Type Information

In the process of writing an import system for importing data into a database modeled by EF, I needed to be able to grab table/column information from the model.  Following is a method I wrote for doing that (it's more difficult than it seems).

First, here is the class I'm populating in the main method.  Of course, you could add properties to this as necessary:

Update:  There is a bug in the code below.  It's impossible to edit the (pasted in) HTML now.  the select after "var foreignKeyNames" below should be:
select ( p.FromEndMember.RelationshipMultiplicity == RelationshipMultiplicity.One ) ? 
( (AssociationType)p.RelationshipType ).ReferentialConstraints[0].FromProperties[0].Name :
( (AssociationType)p.RelationshipType ).ReferentialConstraints[0].ToProperties[0].Name );

public class EntityTypeInfo
{
    public string EntityName { get; set; }
    public string PropertyName { get; set; }
    public Type EntityType { get; set; }

    ///
    /// Identity, Computed columns
    ///
    public bool StoreGenerated { get; set; }
    public bool IsForeignKey { get; set; }
}

Now the main method along with a helper method (see update above):

44. /// <summary>
45. /// For the given table/entity list, build a list of type info.
46. /// </summary>
47. public static List<EntityTypeInfo> SimplePropertiesFrom( ObjectContext context, List<string> tables )
48. {
49.     var result = new List<EntityTypeInfo>();
50.  
51.     /// We have to draw from two different spaces to get all the info we need.
52.     var conceptualMetadata = context.MetadataWorkspace.GetItems( DataSpace.CSpace );
53.     /// context.MetadataWorkspace.GetItems() for storage space only works if queries have already run which we can't ensure here.
54.     var storageMetadata = ( (EntityConnection)context.Connection ).GetMetadataWorkspace().GetItems( DataSpace.SSpace );
55.  
56.     var query = from c in conceptualMetadata
57.                 join s in storageMetadata on
58.                     c.BuiltInTypeKind == BuiltInTypeKind.EntityType ? ( (EntityType)c ).Name : "X" // If the item isn't an EntityType, we don't want a join, so just make these 2 values different
59.                     equals
60.                     s.BuiltInTypeKind == BuiltInTypeKind.EntityType ? ( (EntityType)s ).Name : ""
61.                 where c.BuiltInTypeKind == BuiltInTypeKind.EntityType
62.                 select new { conceptual = c as EntityType, storage = s as EntityType };
63.     query.ToList().ForEach( field =>
64.     {
65.         if ( tables.Contains( field.conceptual.Name ) )
66.         {
67.             var foreignKeyProps = ( from p in field.conceptual.NavigationProperties
68.                                     where p.RelationshipType is AssociationType && ((AssociationType)p.RelationshipType).IsForeignKey
69.                                     select ( ( AssociationType )p.RelationshipType ).ReferentialConstraints[0].FromProperties[0].Name );
70.             foreach ( var p in field.conceptual.Properties )
71.             {
72.                 result.Add( new EntityTypeInfo
73.                 {
74.                     EntityName = field.conceptual.Name,
75.                     PropertyName = p.Name,
76.                     EntityType = ( (PrimitiveType)p.TypeUsage.EdmType ).ClrEquivalentType,
77.                     StoreGenerated = IsStoreGenerated( p, field.storage ),
78.                     IsForeignKey = foreignKeyProps.Contains( p.Name )
79.                 } );
80.             }
81.         }
82.     } );
83.     return result;
84. }
85.  
86. private static bool IsStoreGenerated( EdmProperty conceptualEntityProperty, EntityType storageEntityType )
87. {
88.     EdmMember storageProperty;
89.     storageEntityType.Members.TryGetValue( conceptualEntityProperty.Name, true, out storageProperty );
90.     if ( storageProperty == null )
91.     {
92.         return false;
93.     }
94.     else
95.     {
96.         Facet f;
97.         if ( storageProperty.TypeUsage.Facets.TryGetValue( "StoreGeneratedPattern", false, out f) )
98.         {
99.             return ( ( (StoreGeneratedPattern)f.Value ) == StoreGeneratedPattern.Identity ) || ( ( (StoreGeneratedPattern)f.Value ) == StoreGeneratedPattern.Computed );
100.         }
101.         else
102.         {
103.             /// If it's not store generated, the above property won't be there (StoreGeneratedPattern.None is never referenced).
104.             return false;
105.         }
106.     }
107. }