Unable to load the specified metadata resource

Exception Description:
og-bit.com

Exception Details: System.Data.MetadataException: Unable to load the specified metadata resource.

Resolution:

This error is often generated when we are using the Entity Framework for database access. The error means that there is a problem with finding the metadata information to allow the Entity Framework to work properly and translate queries against the conceptual model. At design time, the database entity model is created in the .edmx file. After compilation, the metadata information is stored as a resource in three different files:

• .csdl  Conceptual Schema Definition Language
• .ssdl  Store Schema Definition Language
• .msl Mapping Specification Language

By default, these files get generated and embedded as a resource on the assembly. To find the location of these files, the Entity Framework uses the entities connection string in the config file. If you take a look at a config file, we will find this setting:

<connectionStrings>

    <add name="GalleryEntities" connectionString="metadata=res://*/Gallery.csdl|

res://*/Gallery.ssdl|

res://*/Gallery.msl;

provider=System.Data.SqlClient;provider connection string=&quot;data source=localhost\sqlexpress;initial catalog=…;App=EntityFramework&quot;" providerName="System.Data.EntityClient" />

  </connectionStrings>

For this project, we can see that the connection string indicates that all the files should be found on the default assembly’s (*) resources, and their names match the Gallery.* pattern. We are getting an error, so there is something not matching here. We will need to compile the code and inspect the assembly using reflector or ilspy.  These applications let us decompile assemblies, so we can browse their content. After opening the assembly, look at the resources folder, we should see the files there. In my case, there was a problem with the way the files get generated. The actual name of the files is Models.Gallery.*.  If you correct those entries in the config file, the connection string should now read as follows:

<connectionStrings>

    <add name="GalleryEntities" connectionString="metadata=res://*/Models.Gallery.csdl|

res://*/Models.Gallery.ssdl|

res://*/Gallery.msl;

provider=System.Data.SqlClient;provider connection string=&quot;data source=localhost\sqlexpress;initial catalog=…;App=EntityFramework&quot;" providerName="System.Data.EntityClient" />

  </connectionStrings>

We can now run the application, and the data should load with no problems.  If this was not the problem for your project, you should also make sure in which assembly the resource files are located. If it is not in the default assembly, you should replace the * in the connection string with the name of the correct assembly. For example:

connectionString="metadata=res://myassembly.dll/Models.Gallery.csdl|

res://myassembly.dll /Models.Gallery.ssdl|

res://myassembly.dll /Gallery.msl;

That indicates that those files are embedded as a resource in a different dll. I hope this provides some help in resolving this metadata exception.

Exception Description: og-bit.com Exception Details: System.Data.MetadataException: Unable to load the specified metadata resource. Re...

Read Article →

What is the difference between ObjectSet and EntityCollection?

When working with the Entity framework, you may see that there are two types of collection created, ObjectSet and EntityCollection. Many of us get a bit confused as of why there are two types of collections and about their use. I will try to describe my understanding of their differences:

ObjectSet Definition from MSDN:

public class ObjectSet<TEntity> : ObjectQuery<TEntity>,

        IObjectSet<TEntity>, IQueryable<TEntity>, IEnumerable<TEntity>,

        IQueryable, IEnumerable 

where TEntity : class

ObjectSet provides access to entities/tables of a database.  ObjectSet is IQueryable which means that when you use this reference with a LINQ query, the expression is changed to the SQL expression for the provider (i.e. Entity classes mapping to SQL Server). This is how LINQ works for the LINQ to Entities expressions to be able to select records from the database.

EntityCollection Definition from MSDN:

public sealed class EntityCollection<TEntity> : RelatedEnd, 

        ICollection<TEntity>, IEnumerable<TEntity>, IEnumerable, IListSource 

where TEntity : class

EntityCollection is a collection type which represents “many” entities. When we use LINQ to query an EntityCollection, we are using LINQ to Objects to retrieve the “in-memory” objects in the collection, and no query is executed in the database.  The records for this collection are the ones associated to a main entity as a property and are loaded using the Load method which uses an ObjectSet to load the records from the database. Look at this pseudocode:

VehicleMake: IQueryable{                //represents the ObjectSet

        VehicleModels:IEnumerable      //represents an EntityCollection populated by Load()

}

VehicleModels:IQueryable{// ObjectSet which gets the records from the database

}

og-bit.com

When the collection is a property is an EntityCollection.

I hope this is able to help some of you.

When working with the Entity framework, you may see that there are two types of collection created, ObjectSet and EntityCollection. Many of...

Read Article →

Invalid Expanded Name LINQ to XML

In the System.Xml.Linq API, the concatenation of the namespace and a local element name creates the expanded name. When an invalid expanded name exception is raised, it can occur when a LINQ to XML query uses an element attribute, and the attribute name that is used is an empty string. For example, with an Xml like this:

<Items>

<item id=”1”>one</item>

<item id=”2”>two</item>
<item>three with no id attribute</item>

</Items>

If you query the document with the following syntax: (get all the items with the attribute id)

var nodes = (from item in Xml.Descendants()

             where item.Attribute(NodeId) != null

             select item).ToList<XElement>();

If the NodeId string variable has no value, the exception of the invalid expanded name will be raised. To address this, we should check that the string is not empty before executing the LINQ query. We can also rewrite the query to something like this:

var nodes = (from item in Xml.Descendants()

             where (!String.IsNullOrEmpty(NodeId) && item.Attribute(NodeId) != null)

             select item).ToList<XElement>();

The IsNUllOrEmpty call prevents the execution of the attribute call when NodeId is empty.

I hope this helps.

In the System.Xml.Linq API, the concatenation of the namespace and a local element name creates the expanded name. When an invalid expanded ...

Read Article →

How to Clone XDocument

The XDocument class does not implement the ICloneable interface, so there is no Clone method to call. There is however a constructor that allow us to do this. The constructor takes an instance of XDocument and creates a new instance with the same XML structure. This can be done with the following code:

string xmlString = "<items><item/><item/></items>";
..

TextReader tr = new StringReader(xmlString);      
XDocument originalDoc = XDocument.Load(tr);
XDocument cloneDoc = new XDocument(originalDoc);

cloneDoc is a new instance that has the same XML document. Any changes to the cloneDoc does not affect the originalDoc XML document.

I hope this helps.

The XDocument class does not implement the ICloneable interface, so there is no Clone method to call. There is however a constructor that al...

Read Article →

LINQ to Entity Inner and Left Joins

In SQL, we can joins tables using inner and left joins as follows:

Inner Join: the following query returns only the products that have a valid category id.

Select prod.id, prod.name, cat.name

From product prod

Inner join category cat on prod.catid = cat.catid

Left  Outer Join: the following query returns all the products even if there is no valid category id

Select prod.id, prod.name, cat.name

From product prod

Left outer join category cat on prod.catid = cat.catid

If you are using the Entity framework and you are trying to join entities in your code, you can rewrite the queries using entity SQL as follows:

Inner Join:

This looks basically the same as a normal SQL inner join. The join is between product and category on the catid field. If no category exists, no data would return.

var list = from proc in en.Product

                join cat in en.Category on proc.catid equals cat.catid

                 select new{

                                id = prod.id,

                            name=prod.name,

                                category=cat.name

                 }

Left Outer Join:

The following example does a group join between product and category. This is essentially the left join. The into expression returns data even if the category table is empty. To access the properties of the category table, we must now select from the enumerable result by adding the from cl in catList.DefaultIfEmpty() statement.

var list = from proc in en.Product

                join cat in en.Category on proc.catid equals cat.catid into catList

               from cl in catList.DefaultIfEmpty()

                select new{

                                id = prod.id,

                            name=prod.name,

                                category=cl.name

                 }

I hope it helps.

In SQL, we can joins tables using inner and left joins as follows: Inner Join: the following query returns only the products that have a va...

Read Article →

LINQ to SQL Using Where in

In SQL, you can compare against multiple values by using the IN operator. A normal select statement with the IN operator looks as follows:

select * from AuditLog

where log_id in (1111,2222,3333)

What if we need to use LINQ to SQL to accomplish the same? The approach is to use an array and use the Contains method to compare against the columns values. This is what the SQL statement listed above looks in LINQ:

int[] ids = { 1111, 2222, 3333 };

from log in dbcontext.AuditLog

where ids.Contains(log.log_id)

select log

We first declare an integer array with the values we are looking for. We then use the Contains method to compare the values. If you add a SQL trace, you will be able to see how this LINQ statement is translated into a SQL statement that uses the IN operator.

*Note:  dbcontext is the data context class that is created when a dbml file is added to the project. This is what generates the LINQ classes that are used for the database access.

I hope this is useful.

og-bit.com
CodeProject

In SQL, you can compare against multiple values by using the IN operator. A normal select statement with the IN operator looks as follows: ...

Read Article →

LINQ to SQL with NOLOCK

If your project uses LINQ to SQL for your database access, you may want to use NOLOCK to set the isolation level to ReadUncommitted on your select statements. This prevents the database engine from issuing locks on the tables that we are trying to select data from which helps increase concurrency and performance.


The area of concern is that LINQ does not understand query hints. The way this works with LINQ is by running your select statements under the context of a transaction scope as follows:

string type = string.Empty;

og-bit.com

using (DataContext ctx = new DataContext(ConnectionString))

{

  using (var tx = new System.Transactions.TransactionScope(TransactionScopeOption.Required,

         new TransactionOptions() { IsolationLevel = IsolationLevel.ReadUncommitted }))

  {

         var row = (from record in ctx.Log

                    where record.Id == 99999

                    select record).FirstOrDefault();

         type = row.Type;

  }

}

The code here creates a transaction scope and sets the isolation level to ReadUncommitted (NOLOCK). The select statement runs under the scope of the transaction, and it returns the value from a query. The using clause ensures that both the transactions as well as the data context are disposed once the code goes out of scope.

There is also the preferable option to use stored procedures to eliminate the need to use transaction scope. In the store procedure, you have the flexibility to use query hints.

I hope this helps.

og-bit.com
CodeProject

If your project uses LINQ to SQL for your database access, you may want to use NOLOCK to set the isolation level to ReadUncommitted on your ...

Read Article →