Ido Flatow

No more URL copy & paste for me !

Ido Flatow — Tue, 02 Mar 2010 16:35:21 GMT

Ever wrote a word document where you needed to use a lot of hyperlinks? You need to go to your internet site, copy the URL, go back to the document, mark you text, right-click, select “Hyperlink”, paste the address in the link textbox and press OK ! well, no more !

Apparently there is a better technique to do this in word:

Mark your text, right-click it and select “Hyperlink” from the context menu.
Open the required site in your browser (you can also move to an already opened browser).
Move back to the word document where the Hyperlink dialog is already opened.

Presto ! the address of the site you were just in will appear in the hyperlink's textbox !

Unfortunately, this feature only uses URL from internet explorer, so for all of you firefox / chrome fans, you need to stick with copy & paste.

Devart’s Entity Framework provider for Oracle, now for EF4 !

Ido Flatow — Tue, 09 Feb 2010 14:45:37 GMT

It’s finally here, an Entity Framework 4 provider for oracle, complements of Devart.

You can download the provider (trial version of course) from here, look for version 5.55 beta.

Communicating From Silverlight 4 – My session at the SDP

Ido Flatow — Wed, 30 Dec 2009 19:04:10 GMT

Today at the SDP I gave a lecture on the different ways we can communicate with the web from Silverlight 4. We talked about the different HTTP Stacks Silverlight offers and the many communication types & technologies you can use, such as:

Simple http requests
Restful services
Syndication (Rss/Atom) feeds
ASMX Web Services
WCF services
WCF Data Services
TCP communication
UDP communication

Yes, you can do all the above with Silverlight 4 !

In addition, we talked about different WCF scenarios that you can achieve in Silverlight 4, such as:

Binary message encoding
Catching SOAP Faults
Passing HTTP & SOAP Headers
Authentication
Using Duplex

You can download the presentation and the code samples from here.

The lecture’s recording will be available from the SDP site in a few days, so stay tuned…

My ORM presentation at SDP (Sela Developer Practice)

Ido Flatow — Mon, 28 Dec 2009 09:11:49 GMT

Just finished passing my presentation about ORM & Entity Framework basics

This presentation is part of a whole-day seminar about ORM Tools & Concepts

Currently Bernie & Erez are demonstrating NHibernate & Entity Framework head-to-head and later on Gil will deep dive into Entity Framework and Erez & Bernie will once again join forces to talk about Data Access Pattern in the real world.

We’ll finish the day with an Expert Panel, where Oren Eini will join us to talk about ORMs, NHibernate, Entity Framework, Pattern, Tips & Tricks and more.

Be sure to download the presentation from our blogs. Video recordings will be available after the SDP.

Handling SOAP Faults In Silverlight

Ido Flatow — Tue, 08 Dec 2009 11:00:16 GMT

In the past, when we tried to connect from Silverlight 2 to WCF Services that threw exceptions (every now and then), we got the famous “Not found” Communication Exception.

The reason we didn’t get a SOAP Fault is that WCF returns SOAP Fault responses with a HTTP code of 500 – this is according to SOAP protocol, but the browser doesn’t allow 500 responses to be returned to Silverlight – it replaces them with a CommunicationException and thus hides the real fault that returned.

When we moved to Silverlight 3, Microsoft published the following article, describing how to workaround the browser’s block, using a Message Inspector in the WCF-side to replace HTTP 500 fault responses with a HTTP 200 fault responses, thus allowing Silvelright to get these messages.

But… this fix will make your WCF service not compatible with the SOAP protocol, not mentioning you’ll have a whole new inspector to manage (test, debug, maintain…), and you’re debug skill will need to improve (try using fiddler to find these errors when the return code is 200 and not 500 – no red lines !!).

There is another solution that isn’t discussed much, and doesn’t require making any changes in WCF – changing the HTTP Stack Silvelright uses for the services.

In Silverlight 3 a new HTTP Stack was released – the Client HTTP Stack. The Client Stack uses the OS directly to create network operations, instead of using the browser. The new stack can be used instead of the Browser’s HTTP Stack for http and https. There are some differences between the stacks, one of them being the Client’s stack ability to handle all types of responses, including HTTP 500 responses.

To use the Client Stack for a specific service, just add the following code at the beginning of your Silverlight application (just change the url):

HttpWebRequest.RegisterPrefix(http://localhost/services/serviceX, 
WebRequestCreator.ClientHttp);

The above line of code will tell Silverlight to use the Client stack whenever a call is made to a URL with that prefix – all other calls will use the Browser stack. If you want all calls to go through the Client stack, use a prefix of “http://”

You can read more about the ClientHttp class here, or just come to the SDP (registration required), where I will talk about the Client stack and other changes made in Silverlight 3 & Silverlight 4 that improves Silverlight’s ability to use network resources.

There are going to be many cool stuff in the SDP lectures, straight from the PDC, I myself still haven’t decided which lectures to go to (WCF 4? ASP.NET 4? WF? many to choose from).

PDC 09 – Entity Framework 4

Ido Flatow — Wed, 18 Nov 2009 01:27:00 GMT

First time that I can say – there are MANY people that use EF4. How do I know? because the session had the room filled with people, with people waiting outside !

EF 4 is great. It solved many of the problems of EF3.5 and made the technology more mature and useful.

What annoyed me in the lecture is that it showed all the features of EF4 that people already know of (well, I know of). The title was misleading because I thought they will talk about new features that don't exist currently.

Here is the list of features, and links to blog posts regarding them:

One new think that was introduced was the “Quadrant” project – cool graphical tool that allows editing SQL Server data.

I’m not saying the session wasn’t good, for people that are unfamiliar with EF4, the session was great and it covered a lot of new features. For someone like me that is familiar with EF4 since the first beta, the session didn’t add much.

Don’t forget the Entity Framework session and tutorial on the SDP – we’ll have a session about Entity Framework 4 (for those who are unfamiliar) and will have a whole day of EF & ORM tutorials with the best EF guys in Sela (Erez Harari, Gil Fink, Bernie Almosni and myself).

PDC 09 updated – ASP.NET 4 Futures

Ido Flatow — Wed, 18 Nov 2009 00:59:00 GMT

I must admit, I had not used ASP.NET for a long time (lately I’m a Silverlight fan), so most of the things were new to me. What I liked about this session is that it was indeed about “Futures” because some of the things shown were still in development.

The topics discussed:

Helpers
1. RAD development using ActiveRecord over Entity Framework for Asp.Net MVC
2. Introducing TaskScheduler to perform background tasks (no need to code with System.Threading no more)
3. Sending Emails with verification
4. New control for file upload with progress bar
5. Simple mechanism for using routing with web forms (aspx).
  Instead of using “\App\Welcome.aspx” use “App\Welcome”.
  This is being done with the new SmartyRoute class (I have a feeling that this name will change when the RTM is released).
HTML5
1. The menu control is now implemented under HTML5 as a <menu> element.
2. The team is checking how to incorporate new HTML5 standards such as <video> and <audio> elements
3. Web Storage can be accessed with AJAX using the IntermediateDataContext (Again, I have a feeling that the name will change) which works together with the existing AdoNetDataContext class
Caching
1. Velocity implementation for Session state provider - but that we already know (if not, take a look at a lecture I did).
2. Velocity implementation for OutputCache. For this the OutputCache was changed to support provider mechanism, so you can actually write your own provider for the output cache.
CSS sprites: CSS sprites are used to optimize download of images, instead of making the browser run multiple requests to get numerous images, the browser sends one request to get a large image, constructed of all the images and CSS styles are used to specify which section of the large image should be displayed in each element.
1. CSS sprite support is added to ASP.NET (just change the “Images” folder to “Sprites”) – You can control whether you want sprites or not using the SpriteGroups class.
2. You can use a sprite image class to specify when you want to get an image as a sprite:
  <%= Html.SpriteImage(elementName, altText)%>
3. The generated code is a DIV element that uses the background-position CSS attribute
ActiveRecord
1. Used to wrap Entity Framework and to provide easier usage of the technology
2. Implemented to be used in Asp.Net MVC
3. Allows automatic creation of SQL Compact edition databases (MDF file)
4. Supports automatic DB table changing when the entity class is changing (for example – adding a property to an entity results in a new column in the table).
  Nice feature – not sure how it will work in production environments

To conclude, I enjoyed this lecture, looking forward to the release of Asp.Net 4 with VS 2010.

As for HTML5 – funny that all the demos were in FireFox and not IE8.X. When will IE support HTML5? If the Asp.Net team accepts that HTML5 is coming, shouldn’t the IE team also start working on the matter?

We will discuss Asp.Net 4 on the SDP which will be on December, so don’t forget to register.

PDC blogging – Data Programming and Modeling

Ido Flatow — Tue, 17 Nov 2009 21:40:00 GMT

As I've stated before, I attended the data programming and modeling session - And I enjoyed every minute. Chris Anderson and Don Box rock !

They talked about Entity Framework 4 – The automatic lazy load (no more need to call the damn Load() method), different approached of model first, POCO and code only (using the fluent API) etc.

There was a talk about code first having a configuration class instead of writing all the fluent API by hand, and without having to add attributes to your POCO classes - that is something worth checking out.

They also showed the new Transact Sql editor that was shipped with VS2010, Which allows running TSQL queries and also has intellisense:

After talking about EF we got to the real deal - ODATA (Open Data Protocol) that allows producing and consuming data through various applications, for example export Sharepoint data and consume with Excel,

If you want to expose your data using the OData protocol you can easily build a service using the ado.net data services. To describe the data returned from these services you don't use XSD schemas anymore but rather... the EDM (Entity Data Model) ! A new use for the well known EF's EDM.

Last, but not least, they showed bits from project “M” - you can take an EDMX file, rename its extension to “.M” in VS and it will automatically change to a “M” model and vice versa – I tried it in VS 2010 beta 2 but it didn’t work, maybe it part of the next version ?. This project is quite new and I didn’t had a chance to look at it yet, but there are some lectures on the project in the following days which I’ll try to attend and post about later on.

PDC 2009 First Impression

Ido Flatow — Tue, 17 Nov 2009 19:05:00 GMT

Wow ! I’m not familiar with events of this size. For me, Israeli Tech-Ed was the biggest event I attended.

Well, there’s something strange about flying 20 hours to the far end of the world, going to a city with million of people of different types, and entering a conference center will thousands of geeks moving around.

First Keynote was interesting, a lot of talking about “3 screens and a cloud”, cloud in general, Azure in specific. Many new features in VS2010, IIS, and Windows to support all the features of Azure and such.

I’m looking forward to the different session. My interest is in the technologies I use in my day to day work – Silverlight, Entity Framework, WCF, Asp.Net & VS2010 & TFS.

Currently I’m sitting in the Data Programming and Modeling for the Microsoft .NET Developer session, talking about EF more.

Don’t forget, in the coming SDP we’ll talk about EF 4 and we’ll have a full day of ORM & EF tutorials

Implementing Composite design pattern in Entity Framework

Ido Flatow — Tue, 17 Nov 2009 01:55:00 GMT

Last week, a colleague of mine asked me to create a sample composite design pattern model in Entity Framework. I thought to myself, no problem, created the table that contains the Component, Leaf & Composite entities (according to TPH – Table Per Hierarchy) and went to build the EDM based on the table and there I started to have problems which needed manual fixing. Since I’m working with EF 3.5, I’ve built the DB prior to the model – In EF 4.0 you can do model-first and build your db by script.

After reverse engineering the db table, I got one entity named “CompositePattern”. From there I had to do some things in the designer and some things manually:

In the designer, change the name of “CompositePattern” to “Component”.
Mark the entity abstract.
Create a new entity, called “Leaf” and base it on the “Component” entity.
Move the required properties from the “Component” type to the “Leaf” type by cutting & pasting the scalar properties (You may need to set the mappings for the properties you’ve moved).
Create a new entity, called “Composite” and base it on the “Component” type.
Now comes the tricky part – moving the children relation from the “Component” type to the “Composite” type. This cannot be done in the designer, only straight in the XML itself.
Before changing the navigational property, note that there are two navigational properties for the composite->component relation - one on each side: a navigational property “Children” from “Composite” to “Component”, and another navigational property “Parent” from “Component” to “Composite” – This is what we’ll need to change in the EDMX file.
Open the EDMX file with a xml editor (right-click the .EDMX file and choose “Open with…” and select “XML Editor”.
Since EF’s wizard didn’t name the navigational properties correctly, we’ll start by finding and replacing them. You can identify which navigational property is the parent and which is the children according to the multiplicity – the “Parent” should be marked as “0..1” and the “Children” should be marked as "*” (in my case it was “CompositePattern” and “CompositePattern1” accordingly) – Locate all the occurrences of these names and replace them with “Parent” and “Children” accordingly.
Now that we named the navigational properties and associations, we ca start changing things. The changes are only in the CSDL part:
1. Locate the association element for the composite->component relation (If you’re working in a new model, you should have only one association element) - Change the type of “Parent” to “Composite” (because parents are always of type composite)
2. Locate the “Children” navigation property in the “Component” type and move it to the “Composite” type.
Close the file. You can try to open it again in the designer, for me it did not work with EF 3.5 and VS 2008 SP1, but did work with EF 3.5 and VS 2010 Beta 2.

Write some code to insert composites and leafs and see how it works.

If you got mixed up and didn’t manage to create the composite model, no fear – the sample model can be downloaded from here.

The sql for building the db table (In SqlServer) is:

CREATE TABLE [dbo].[CompositePattern](
      [ID] [uniqueidentifier] NOT NULL,
      [FirstName] [varchar](50) NULL,
      [LastName] [varchar](50) NULL,
      [ParentID] [uniqueidentifier] NULL,
      [Type] [int] NOT NULL,
 CONSTRAINT [PK_CompositePattern] PRIMARY KEY CLUSTERED 
(
      [ID] ASC
)WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF
, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]

I will continue to post some more Entity Framework tips & tricks this week while I'm attending the PDC, and of course post about the new stuff discussed in the conference.

Just to remind you all, in December we’re having the SDP where we will talk a lot about Entity Framework and ORM in general, don’t forget to register.

Entity Framework View Generation Fixup

Ido Flatow — Mon, 16 Nov 2009 20:45:00 GMT

A few day ago, a colleague of mine, Shlomo Goldberg, raised a question about Entity Framework and large models. Another colleague of mine, Gil Fink posted some links to helpful tips for using large models, and I want to talk about one of these tips – using the View Generation option.

If you’ve worked with large models in Entity Framework 3.5, you probably noticed that as the model grows, it takes more time to initialize the ObjectContext for the first time. A solution to this is to use view generation, using the EdmGen tool, which can reduce up to 30% of the time it takes to initialize the context for the first time.

If you’ve tried to use the view generation for very large models (80+ entities), you probably noticed that the generation it self takes a lot of time to complete, the output code file is very large (we’ve reached up to 70Mb) and if the model is very large and complex (large inheritance trees are a big contributor), the generated file can sometimes makes Visual Studio crash on opening and compiling.

If you look at the generated file content, you’ll see that it includes many if/else/if statements, that looks something like this:

if (index == 0)
{
}
else
{
   if (index == 1)
   {
   }
   else
   {
      …
   }
}

This structure of code is problematic for the following reasons:

It creates a very large if/else/if tree, that at some point cannot be translated by the compiler
The canonical if/else/if will sometimes cause Visual Studio to crash (I assume whoever created VS didn’t think someone will use that many if/else/if statements)
The whitespaces used to create this form causes the size of the file to be extremely large

So what can you do?

You can move to Entity Framework 4.0 (currently in beta) where the view generation was fixed. In EF4 the generated code is of the form:

if (index == 0)
{
}
if (index == 1)
{
}

If you can’t or don’t want to move to EF4, you can edit the generated file and change the structure of the code to make it similar to the one generated by EF4 (remove brackets and whitespaces). Since this file can be auto generated and it’s a waste of time doing find & replace, I’ve attached a Powershell script that performs the changes. Using this script can reduce the generated file size a lot (sometimes up to 90% reduction of file size).

If you’re interested in learning more about Entity Framework or about ORM in general, we’ll be discussing these topics and more in the SDP on 27-30 of December.

This week I’ll continue to write more posts about Entity Framework Tips & Tricks, directly from the PDC (Los-Angeles), and hopefully some of these posts will contain new insight to Entity Framework 4.0 and future roadmap

הרצאת Velocity בכנס ביצועים

Ido Flatow — Tue, 20 Oct 2009 14:39:57 GMT

למי שנכח בכנס הביצועים בממר”ם בהרצאה שלי, ראשית תודה על ההקשבה, נהניתי מאוד מהשאלות, ושנית מצ”ב קישור להורדת המצגת ודוגמאות הקוד.

Entity Framework 4 Lecture at the Web Developers Community (WDC)

Ido Flatow — Sun, 06 Sep 2009 21:29:39 GMT

Just wanted to say I had a great time giving this lecture. I’m pleased to hear people learned more than just about entity framework.

Big thanks to Noam King for inviting me to give this lecture, and to Guy Burstein & MS for the accommodations.

I’ve uploaded the presentation, code samples (Both EF 3.5 & 4.0) and the sample DBs I’ve used (as .MDF files, you’ll need to attach them to your db to make them work).

You can download the entire file from here.

מאמר היכרות עם Ado.Net Entity Framework

Ido Flatow — Mon, 31 Aug 2009 10:33:56 GMT

לפני מספר ימים עלה לאתר מאמרי MSDN בעברית מאמר שכתבתי בנושא Entity Framework.
המאמר הינו ברמת היכרות ומטרתו להציג את הטכנולוגיה ואופן השימוש ב-EF.
המאמר מיועד גם למי שלא מכיר את הטכנולוגיה וגם לאלו שמשתמשים ב-EF ומעוניינים להכיר את הארכיטקטורה של המוצר.

תודה לגיא בורשטיין ממיקרוסופט על העלאת המאמר. אם הייתם רוצים לראות עוד מאמרים בעברית בנושא Entity Framework, אשמח לקבל בקשות לנושאים (בין אם ברמת מתחילים או מתקדמים).

אם כבר עסקיננו ב-Entity Framework, ב-6 לספטמבר 2009 אני אעביר הרצאה בנושא Entity Framework ב-Web Developers Community (קהילת/קבוצת מפתחי WEB), פרטים על המפגש ניתן למצוא באתר ההרשמה

ExpressionType.And VS ExpressionType.AndAlso

Ido Flatow — Wed, 26 Aug 2009 15:37:27 GMT

Today I’ve encountered a strange problem running expressions - I wanted to created an expression tree that looks something like this:

(e) => e.Owner != null && e.Owner.ID = 4455

So I’ve used the Expression.MakeBinary method to create a binary expression and passed it an ExpressionType.And enum, thinking this is the C# “&&” operator.

When running the expression on an e instance that had no owner (null), I got an exception. When looking at the created expression it looked something like this:

(e) => e.Owner != null AND e.Owner.ID = 4455

At first I didn’t notice any difference (I just thought the ToString() created an easy-to-read string), but after comparing it with the same expression written by hand with a lambda expression, I noticed the difference between the “AND” operator and the “&&” operator.

As it turns out, ExpressionType.Add is actually a bit-wise operator (similiar to &) and the enum that matches the && operator is the ExpressionType.AndAlso (the && operator is what is called a short-circut evaluator).

This is the same with the || (or) operator – the ExpressionType.Or is the bitwise or, whilst the ExpressionType.OrElse is the actual “||” operator.

I honestly think that it would have been better if they named this types as ExpressionType.BitwiseAnd and ExpressionType.And – makes more sense, doesn’t it?

So be careful the next time you want to use and/or in your expression tree.

Further links:

http://en.wikipedia.org/wiki/Short-circuit_evaluation

http://msdn.microsoft.com/en-us/library/bb353520.aspx