We Keep Coding

Asp.net MVC Many to Many Junction Table

My dbContext always returns null for my junction table. Can I solve the problem by not changing the DB relationship design?
My problem
I want just Id = 1 and Stationery_Id = 1 and UOM_Id = 1
Here is all the detail information...
Database Design
Class
Data in my db

I think it's related to lazy loading. As this tutorial said:
Lazy loading is delaying the loading of related data until you specifically request for it
You never ever request related data directly in this code snippet, so the expectation of loading related data is wrong.
If you wanna load related data at the moment, you can use Include to achieve that:
db.StockUOMs.Include(i => i.UOM).Include(i => i.Stationery).ToList();
for a deep dive, you can follow this link.
good luck.

differences between Eager Loading and Explicit Loading

Eager Loading:
context.Cars.Include(c=>c.Orders)
Explicit Loading:
context.Entry(c).Collection(x => x.Orders).Load();
what's the differences between Eager Loading and Explicit Loading? is it just syntax differences like Eager Loading uses Include while Explicit Loading uses Load?, but isn't that using Include is also an "explicit" way to load navigation properties, so why Eager Loading is not considered the same as Explicit Loading?

Eager loading is the opposite of Lazy loading, but Explicit loading is similar to lazy loading, except that: you explicitly retrieve the related data in code; it doesn't happen automatically when you access a navigation property.
You load related data manually by getting the object state manager entry for an entity and calling the Collection.Load method for collections or the Reference.Load method for properties that hold a single entity.
EntityFramework returns IQueryable objects, which essentially contain the query to the database. But these are not executed until the first time they are enumerated.
Load() executes the query so that its results are stored locally.
Calling Load() is the same as calling ToList() and throwing away that List, without having the overhead of creating the List.

Eager loading loads related entities as part of the query, i.e. the enties are loaded when the query is actually executed. This is the opposite of lazy loading where the related entities are loaded when you access them through a navigation property.
Calling Load() explicitly loads the entities on your request instead of waiting for you to access the navigation properties. It's for example useful when the initial query doesn't return any related entities (because you didn't use eager loading) and you have disabled lazy loading for whatever reason.

Select a range with Entity Framework

I have an issue trying to maximize the performance of our listview that has pages.
I want the entity framework to do a select statement, but only return a range of the result (range = the items of one page of the listview).
I have searched google but didn't find any results on this. I only found that I can do a .ToList().GetRange(start index, end index), but then all items would be loaded in memory, and that is what I would like to avoid...
Can someone tell me if this can be done? (I don't want to use a stored procedure or view or something like that because our listview has to be reusable...)
Thanks!

You should be able to use .Take(x).ToList()
edit: sorry, try .Skip(startPosition).Take(numberOfItems).ToList()

And if you are not using lazy loading be sure to use Query() before Load() when applying filters to avoid loading the whole collection before applying filters :
context.Entry(blog)
.Collection(b => b.Posts)
.Query()
.Skip(startPosition)
.Take(numberOfItems)
.Load()
.ToList();
When using the Query method it is usually best to turn off lazy loading for the navigation property. This is because otherwise the entire collection may get loaded automatically by the lazy loading
mechanism either before or after the filtered query has been executed.
For more details : http://msdn.microsoft.com/en-us/data/jj574232.aspx

How to say EF , Don't Load all properties!

There is an Entity with many relationships, when i say to EF load a query on a Entity, it loads all properties(OK) with relationships(i don't want)!
This is a big penalty on performance, because i just need some properties not All relationships.
How to say EF that just load entity's property and Don't load relationships (EntityCollection<TEnitity>) ?
I want load relationships's properties by hand!

Are you sure the navigation properties are being eagerly loaded? They shouldn't be by default. Are you using POCO or Code First? If you are, then you need to make sure your navigation properties are marked "virtual". Virtual properties will be lazy loaded.
To check whether navigation properties are lazy loading or eager loading, you'll want to use a tool like SQL Profiler.

JohnnyO is correct; The default value for ObjectContextOptions.LazyLoadingEnabled is false. However, when I create a model from the database, the default value for the model is true. If you are using the generated EF classes, try setting this to false.

Implicit Lazy Loading vs Explicit Lazy Loading

I've been reading Entity Framework and people were crying over why there was not implicit lazy loading or something. Basically I've been searching things about Lazy Loading and now I know what it is : It is a design pattern which allows us to load objects when they are really needed.
But what is the difference between Explicit Lazy Loading and Implicit Lazy Loading.
Thanks in advance...

If you e.g. have an entity "OrderRow" and another entity "Order", there will be a navigational property on the OrderRow that points to the Order it belongs to.
Currently Entity Framework supports only Explicit Lazy Load which means that if you have retreived a number of OrderRows and want to check something on the Order you need to:
// or is an OrderRow
if(!or.Order.IsLoaded)
or.Order.Load()
or.Order.Cancel();
However if you have implicit lazy loading you don't need the IsLoaded check, it will be done automatically, you can do or.Order.Cancel() directly and the Order will be loaded automatically if needed. This is how linq-to-sql works and it saves some typing and some risk for mistakes. On the other hand it makes it less clear exactly when and how database access will be performed. With implicit load it is easy to write inefficient code that makes one DB roundtrip for each line to be fetched from a table.

Explicit means you explicitly wrote your code to lazy load.
Implicit means that the framework (in this case EF) does lazy loading itself, whether you intended to or not.