NuGet 2.2.1 was released on February 15, 2013. The VS Extension version number is 2.2.40116.9051.

This release/update fixes 5 bugs. Here is a link to the issues fixed: http://nuget.codeplex.com/workitem/list/advanced?keyword=&status=Closed&type=All&priority=All&release=NuGet%202.2.1&assignedTo=All&component=All&sortField=LastUpdatedDate&sortDirection=Descending&page=0

It is sometimes hard to find release notes on these updates, so here is a link.

Link: http://docs.nuget.org/docs/release-notes/nuget-2.2.1

A new update to Productivity Power Tools 2012! This update includes a couple of bug fixes including a crashing bug in the Custom Document Tab Well on debug. Download now!

Link: http://visualstudiogallery.msdn.microsoft.com/3a96a4dc-ba9c-4589-92c5-640e07332afd?SRC=VSIDE 
Download: ProPowerTools.vsix

Here are some events in which I’m involved or which are being organized by friends:

February 25, Maine Developer Network (Augusta, Maine): Two topics in this meeting: First What’s New in Entity Framework 5 and second Using NuGet and creating packages. More on: http://www.maine-devnet.org/Home/Meetings.aspx

February 26, Bangor Area .NET Developer (Bangor, Maine): Two topics in this meeting. First Windows Azure and second How to get free/cheap Microsoft software. More on: http://www.bangordevelopers.com/

March 18, SDN Event (Zeist, The Netherlands): A bunch of topics ranging from Delphi for iOS to Windows Azure to SOLID principles. More on: http://www.sdn.nl/SDN/SDNEvent/Events2013/SDNEventMaart2013/tabid/219/Default.aspx

I ran into this today. We needed to delete a project from Team Foundation Service, but there is no way to do this through the UI. Luckily Buck Hodges wrote a post on this already. You need to use the command line TFSDestroyProject.exe tool and make sure to use the VS2012 version, not the VS2010. Also include ‘DefaultCollection’ when specifying the collection name.

Read more here: http://blogs.msdn.com/b/buckh/archive/2011/09/19/how-to-delete-a-team-project-from-tfs-on-azure.aspx

There is a little command line tool that can create the standard ASP.NET membership and authentication tables in an existing SQL Server database instance. (Since I seem to have a hard time remembering the name of the tool I’d figure I’d write a little blurp on my blog to act as a reminder ).

Aspnet_regsql.exe is a command line tool. You can run it without parameters to have it help you in via wizard mode, or apply the right parameters and do it commando-style. See http://msdn.microsoft.com/en-us/library/ms229862.aspx for available parameters.

And if you want to enable the ASP.NET Web Administration Tool on a test or production server, then this forum post http://forums.asp.net/t/932674.aspx/1 tells you how to do that.

The invitations just went out: I’ll be presenting at Augusta Tech Talk on February 25th 2013. There will be 2 sessions; one about NuGet and one about Entity Framework 5.

For more information and registration got to: http://maine-devnet.org/Home/Meetings.aspx

I’ve been using NuGet for years, but recently I’ve been playing with around with NuGet to try and explore some of the lesser known features. I’ve just been using NuGet to effortlessly download and add assemblies to my projects, but where do these files go? And how do I make sure that when I zip my sources and send them to another developer, that person also has everything he needs? How does NuGet play with regards to source control?

Default NuGet Workflow

The default process when using NuGet to install a library (for example EntityFramework) in your project is as follows:

1. Start a new project in a new solution and add the solution to source control.
2. Open the Package Manager Console.
3. Type: “install-package EntityFramework”
4. At solution level NuGet creates a folder named ‘Packages’.
5. NuGet determines the most recently, non-beta, available version of EntityFramework and downloads this file into a folder, named after your package in the ‘Packages’ folder. It also creates a ‘repositories.config’ file to keep track of which projects are using NuGet. The folder may look something like this: 
   
   
   
   Note that all the files in the ‘Packages’ folder and it’s subfolders are automatically added to source control.
6. NuGet adds a packages.config file to your project and uses this to keep track of which packages and versions are installed in the project:
   
   
   
7. When you now check into source control all configuration information as well as all the downloaded packages are preserved and managed in source control.

The default approach works well in most scenarios, but has one downside: if you have a lot packages in your solution, then the size of your source control branch may become larger than desired. This would be less of an issue with say Team Foundation Server, but more of an issue with a DVCS like Mercurial or Git.

Restore During Build Workflow

An alternative approach is offered by using the Enabling Package Restore During Build option. Read the tutorial here to see how it is done.
There are three differences with the default NuGet workflow:

1. A .nuget folder is added to the solution, which contains NuGet.exe, a config file and a build file. These file will be added to source control upon check in.
2. Downloaded NuGet packages in the ‘Packages’ folder (they’re still there) are not added to source control.
3. Every time you (re)build your project the NuGet build step will check to make sure the appropriate NuGet packages have been downloaded.

Zipping projects

As a rule: whenever you want send someone the sources of a project that uses NuGet for maintaining library references, make sure you send the solution, including the packages folder. If you’re using the Restore During Build Workflow, then the zip does not need to contain the actual packages.

Microsoft has just made good on its promise of frequent updates to Visual Studio. The first update for Visual Studio 2012 is now available for download.

Somegar has done a nice blog describing the new features in this update: http://blogs.msdn.com/b/somasegar/archive/2012/11/26/visual-studio-2012-update-1-now-available.aspx

Or jump straight to the download at: http://www.microsoft.com/visualstudio/eng/downloads#d-visual-studio-2012-update

Entity Framework 5 now supports enumerations (when using Visual Studio 2012 and targeting the .NET 4.5 framework).

So let’s have a look. We’ll create a table called Planet with a name and a field to indicate whether it is habitable.

            CREATE
            TABLE [dbo].[Planets](

    [Id] [int] IDENTITY(1,1) NOTNULL,

    [Name] [nvarchar](max) NOTNULL,

    [Habitable] [smallint] NOTNULL,

            CONSTRAINT [PK_Planets] PRIMARYKEYCLUSTERED

(

    [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]

END

Note: the data type for ‘Habitable’ is a smallint.

Next we’ll generate an entity data model from the database. Nothing exciting, since our database has just one table.

When we inspect the properties of the ‘Habitable’ property we see that, as expected, it is mapped to an Int16 (short).

Instead of a short we want to map the field to the following enumeration (note that having the enumeration be of type ‘short’ is significant, the type you select for your enum needs to match the column type in the database):

            public
            enum HabitableEnum
: short

{

  Humanoids = 1,

  Insects = 2,

  Droids = 3,

  None = 4,

  All = 5

}

In order to so, we need to update the model with information about the enum. This is done in the Model Browser.

Look for the “Enum Types” node and right click to add an Enum to the conceptual model.

We can have a locally defined enumeration (to be used in the T4 code generation) or we can refer to the previously defined enumeration by checking the “Reference external type” checkbox.

After adding the enumeration to the model we can now go and update the “Habitable” property in the conceptual model, the enumeration will now be displayed in the type listbox.

If we now browse through the generated code (click the triangle next to the Edmx file in your solution explorer) you’ll see that the generated class for “Planet” is now using the enumeration.

            public
            partial
            class Planet

{

            public
            int Id
{ get; set; }

            public
            string Name
{ get; set; }

            public EF5Demo.Xyz.HabitableEnum
Habitable { get; set; }

}

We can now write some code to insert and query the database. Here is an example:

var ctx = new StarWarsEntities();

Planet p1 = new Planet()
{ Name = "Tatooine", Habitable = HabitableEnum.Droids };

Planet p2 = new Planet()
{ Name = "Coruscant", Habitable = HabitableEnum.Humanoids
};

ctx.Planets.Add( p1 );

ctx.Planets.Add( p2 );

ctx.SaveChanges();

var query = from p in ctx.Planets

where p.Habitable
== HabitableEnum.Humanoids

            select p;

foreach (
var p in query )

{

  Console.WriteLine( p.Name + "
- " + p.Habitable );

}

Console.ReadLine();

When we run it:

That’s all there’s to it. Using enumerations with Entity Framework 5.

But wait, would it not be nice if we could use byte based enumerations and assign multiple values of the HabitableEnum to a planet?

Lets modify the enumeration to use the Flags attribute:

[Flags]

publicenum HabitableEnum
: byte

{

  Humanoids = 0x1,

  Insects = 0x2,

  Droids = 0x4,

  None = 0x8

}

We need to change the type of the ‘Habitable’ column in the database to a tinyint and we need to modify the information in the conceptual schema to inform the entity framework of our change in design:

The screenshot shows that we need to change the underlying type as well as check the “Set Flags attribute”.

We can now write code that assigns multiple values to the habitable field:

using ( var ctx
= new StarWarsEntities() )

{

HabitableEnum x = HabitableEnum.Humanoids;

x |= HabitableEnum.Insects;

Planet p1 = new Planet()
{ Name = "Tatooine", Habitable = HabitableEnum.Droids };

Planet p2 = new Planet()
{ Name = "Coruscant", Habitable = x };

ctx.Planets.Add( p1 );

ctx.Planets.Add( p2 );

ctx.SaveChanges();

var query = from p in ctx.Planets

            select p;

foreach (
var p in query )

{

  Console.WriteLine( p.Name + "
- " + p.Habitable );

}

Console.ReadLine();

}

The output looks like this:

If you wish to query for just insects you need to write a bitwise AND statement, like:

var query = from p in ctx.Planets

where (
p.Habitable & HabitableEnum.Insects ) == HabitableEnum.Insects

            select p;

That’s all folks, have fun!

Entity Framework 5 is included in Visual Studio 2012, but is also available to users of Visual Studio 2010 (as a NuGet package: http://nuget.org/packages/EntityFramework/ ).

Note: Some Entity Framework 5 features are only available when writing an application that targets .NET 4.5. This includes enum support, spatial data types, table-valued functions and the performance improvements.

Read more about what is new on the MSDN ADO.NET blog: http://blogs.msdn.com/b/adonet/archive/2012/08/15/ef5-released.aspx

Update [08-27-2012] : Julie Lerman has an excellent post describing the difference between running EF5 in a .NET 4 versus a .NET 4.5 application, read more on: http://thedatafarm.com/blog/data-access/when-entity-framework-5-ef5-is-not-entity-framework-5-ef5/

For those of us with an MSDN subscription: Windows 8 RTM and Visual Studio 2012 are both available for download. Go to https://msdn.microsoft.com/en-us/subscriptions to get your copy.

I had a little fun today playing with ‘==’ vs. the Equals(…) method. I knew that somewhere in .NET 2.0 (I believe) there had been some improvements in String.Empty versus “”, but I didn’t quite realize that this affected all string literals.

In the code below you can see how value types and reference types may behave differently when using ‘==’ versus the Equals method.
My surprise came when I discovered that line 39 and 41 both return TRUE. Apparently the string literals in an assembly get put in a master list of string constants and then reused where the same string literal gets used. Nice!
The way to force the reference comparison of the string against object to actually be different is to delay the creation of the string until runtime, like in line 52.

             1: 
            static
            void Main(string[]
args)

             2: {

             3:  

             4: 
            // value types
          

             5:  

             6: 
            int x = 10;

             7:  

             8: 
            int y = 10;

             9:  

             10:  Console.WriteLine( x == y ); //
compare by value -> return true

             11:  

             12:  Console.WriteLine( x.Equals( y ) ); //
compare by value -> return true

             13:  

             14:  Console.WriteLine( object.ReferenceEquals(
x, y ) ); // compare by reference -> return false

             15:  

             16:  

             17:  Console.ReadLine();

             18:  

             19: 
            // Reference types
          

             20:  

             21:  StringBuilder s1 = new StringBuilder( "yes" );

             22:  

             23:  StringBuilder s2 = new StringBuilder( "yes" );

             24:  

             25:  Console.WriteLine( s1 == s2 ); //
compare by reference -> return false

             26:  

             27:  Console.WriteLine( s1.Equals( s2
) ); // compare by value -> return true

             28:  

             29:  Console.WriteLine( object.ReferenceEquals(
s1, s2 ) ); // compare by reference -> return false

             30:  

             31:  Console.ReadLine();

             32:  

             33: 
            // object and string
          

             34:  

             35: 
            object o1
= GetName();

             36:  

             37: 
            string o2
= "Mark";

             38:  

             39:  Console.WriteLine( o1 == o2 ); //
compare by reference -> return true

             40:  

             41:  Console.WriteLine( o1.Equals( o2
) ); // compare by value -> return true

             42:  

             43:  Console.WriteLine( object.ReferenceEquals(
o1, o2 ) ); // compare by reference -> return true

             44:  

             45:  Console.ReadLine();

             46:  

             47:  

             48: 
            // object and string
          

             49:  

             50: 
            object ss1 = "Mark";

             51:  

             52: 
            string ss2 = "Markx".Substring(
0, 4 );

             53:  

             54:  Console.WriteLine( ss1 == ss2 ); //
compare by reference -> return false

             55:  

             56:  Console.WriteLine( ss1.Equals( ss2 ) ); //
compare by value -> return true

             57:  

             58:  Console.WriteLine( object.ReferenceEquals(
ss1, ss2 ) ); // compare by reference -> return false

             59:  

             60:  Console.ReadLine();

             61: }

             62:  

             63: 
            static
            object GetName()

             64: {

             65: 
            return
            "Mark";

             66: }

ISO images with the Windows 8 Consumer Preview are now available for download. Go to http://windows.microsoft.com/en-US/windows-8/iso to get the bits.

Microsoft Visual Studio 11 Ultimate Beta has just become available for download. Go to http://www.microsoft.com/download/en/details.aspx?id=28975 to download the bits.

If you’re interested in the Include method in a LINQ to Entities queries to be type-safe, then Joe Ferner has the answer for you in this post: Type-Safe Entity Framework Include: http://www.nearinfinity.com/blogs/joe_ferner/type-safe_entity_framework_inc.html

If you’re using Entity Framework Code First, then you may want to create an index on some of your table. The way to do this is to call “Database.ExecuteSqlCommand” in the “Seed” method of your database initializer. The sample below shows how it is done (thanks to Rolf for pointing me in the right direction):

            using System;

            using System.Collections.Generic;

            using System.Linq;

            using System.Text;

            using System.Data.Entity;

            using System.ComponentModel.DataAnnotations;

            namespace CodeFirstPlayground

{

            class Program

  {

            static
            void Main( string[]
args )

    {

      Database.SetInitializer<CodeFirstSampleModel>( new CodeFirstSampleDbInitializer()
);

            using ( var model = new CodeFirstSampleModel()
)

      {

        var query = from c in model.Customers

            where c.Name != null

                    select c;

            foreach ( var item in query
)

        {

          Console.WriteLine( item.Name );

        }

      }

      Console.ReadLine();

    }

  }

            public
            class CodeFirstSampleModel
: DbContext

  {

            public CodeFirstSampleModel()

      : base( "CodeFirstSampleDB" )

    {

      Customers = this.Set<Customer>();

    }

            public DbSet<Customer> Customers
{ get; set; }

  }

            public
            class CodeFirstSampleDbInitializer
: DropCreateDatabaseAlways<CodeFirstSampleModel>

  {

            protected
            override
            void Seed(
CodeFirstSampleModel context )

    {

      context.Database.ExecuteSqlCommand( "CREATE
INDEX IX_Customer_Name ON Customers (Name) " );

      Customer c = new Customer()

      {

        Name = "Mark",

        LastOrder = DateTime.Now

      };

      context.Customers.Add( c );

            base.Seed( context );

    }

  }

            public
            class Customer

  {

    [Key]

            public
            int Id
{ get; set; }

    [Required]

    [MaxLength( 50, ErrorMessage = "Customer
name must be 50 characters or less." )]

            public
            string Name {
get; set; }

            public DateTime? LastOrder { get; set; }

  }

}

Just a quick service announcement:

Winxnet, in Portland, has started hosting the first Maine based SharePoint User Group.

For more information visit: www.winxnet.com/spugme

I’m honored to have been awarded the Microsoft Most Valuable Professional 2012 Award for contributions in the Visual C# technical communities. I’m honored to be counted amongst the 228 people world wide to receive this award.

“At Microsoft, we believe that technical communities enhance people’s lives and the industry’s success because independent experts, like you, help others extract greater value from products and technologies through the free and objective exchange of knowledge. As a Microsoft MVP, you are part of a highly select group of experts that represent technology’s best and brightest who share a deep commitment to community and a willingness to help others.”
    - Heather Kostes

Thank you Microsoft and thank you Heather! I’m looking forward to organizing more events again this year for the Maine Developer Network and hanging out with the Bangor Area .NET Developers and I’m looking forward to Maine Code Camp #3 and also to meeting my fellow MVPs and product groups in Seattle at the MVP Summit 2012.

- Mark

Sometimes you’re working on a website and you get some images with text in them, but no one remembers what fonts was used in the image. No fear! There is a website call “What The Font” that will take your picture and tell you what font was used: http://new.myfonts.com/WhatTheFont/

Silverlight 5 got released this weekend and can be downloaded here: http://www.silverlight.net/downloads.

Summary of the features

(from the Silverlight 5 download package)

Improved media support

• Low Latency Audio Playback
• Variable Speed Playback
• H/W Decode of H.264 media
• DRM Key Rotation/LiveTV Playback
• Application-Restricted Media

Improved Text support

• Text Tracking & Leading
• Linked Text Containers
• OpenType and Pixel Snapped Text
• Postscript vector printing
• Performance improvements for Block Layout Engine.
  

Building next-generation business applications

• PivotViewer
• ClickCount
• Listbox/ComboBox type-ahead text searching
• Ancestor RelativeSource Binding
• Implicit DataTemplates
• DataContextChanged event
• Added PropertyChanged to the UpdateSourceTrigger enum
• Save File and Open File Dialog
• Databinding Debugging
• Custom Markup Extensions
• Binding on Style Setters

Silverlight 5 performance improvements

• Parser Performance Improvements
• Network Latency Improvements
• H/W accelerated rendering in IE9 windowless mode
• Multicore JIT
• 64-bit browser support

Graphics improvements

• Improved Graphics stack
• 3D

"Trusted Application" model

• Multiple window support
• Full-Trust in-browser
• In-browser HTML support
• Unrestricted File System Access
• P/Invoke support

Tools improvements

• Visual Studio Team Test support

The next Maine Developer Network meeting will be in Augusta on Wednesday November 16th, starting at 9:00am finishing at 12:00 pm.
It is going to be a unique event about Windows Azure: "Playing Games in the Cloud" and will be hosted by Jim O'Neil, Microsoft Developer Evangelist. It will be more of a workshop than just presentation, so bring your laptop and make sure it is prepped to for the class.
For more info see: www.maine-devnet.org

Richard Blewett reminded me that the XmlReader.ReadSubtree method makes it even easier to use LINQ to XML with a streaming approach. The code sample below will load nodes from an arbitrary XML files and yield them to the caller as they’re read from file:

            static IEnumerable<XElement> Load(string filename, string elementName)

{

    XmlReaderSettings settings = new XmlReaderSettings();

    settings.IgnoreWhitespace = true;

            using (XmlReader reader = XmlReader.Create(filename,
settings))

    {

            while (reader.ReadToFollowing(elementName))

        {

            // build element from subtree
          

            XElement element = XElement.Load(reader.ReadSubtree());

            yield
            return element;

        }

    }

}

I just rediscovered this blog post about reading and parsing XML as it becomes available in conjunction with LINQ to XML: http://blogs.msdn.com/b/xmlteam/archive/2007/03/24/streaming-with-linq-to-xml-part-2.aspx

It’s a little dated, but still relevant .

Just came across this great picture of what’s new in .NET Framework 4.5 (click for larger version):

I was implementing a client report (RDLC) using the Microsoft Report Viewer control and I wanted to set the background color of a table field based on value from my object source. At first I used the Color.ToKnownColor() method, but discovered that this does not work for all colors. I needed to convert to Hex. Here is the little extension method I used:

              public
              static
              class ColorExtensions

{

              #region --
Data Members --

              static
              char[]
hexDigits = {

              '0', '1', '2', '3', '4', '5', '6', '7',

              '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};

              #endregion
            

              ///
<summary>
            

              ///
Convert a .NET Color to a hex string.
            

              ///
</summary>
            

              ///
<returns>ex: "#FFFFFF", "#554ECE"</returns>
            

              public
              static
              string ToHexString( this Color
color )

    {

              byte[]
bytes = newbyte[3];

        bytes[0] = color.R;

        bytes[1] = color.G;

        bytes[2] = color.B;

              char[]
chars = newchar[bytes.Length
* 2];

              for ( int i
= 0; i < bytes.Length; i++ )

        {

              int b
= bytes[i];

            chars[i * 2] = hexDigits[b >> 4];

            chars[i * 2 + 1] = hexDigits[b & 0xF];

        }

              return
              "#" + newstring(
chars );

    }

}

I just ran into an issue where I have a WCF service that depends on a .NET assembly that is compiled specifically for x86. In order to use that assembly I need to compile the service as a x86 service. No problem, but now when I want to test or add a service reference to this WCF service I ran into the problem that WcfSvcHost and WcfTestClient both will run a x64 because I’m running Windows 7 x64.

How to solve this? I found the answer in the forums and adapted the answer for my specific problem:

1.Copy WcfSvcHost.exe and WcfTestClient.exe from C:\program files (x86)\Microsoft Visual Studio 10.0\Common7\IDE to a local directory. Keep a backup copy of this file, of course.
2.Start a Visual Studio 2010 Command Prompt (one of the links from the start menu -> Visaul Studio 2010)
3."cd" to the directory where your copy of WcfSvcHost is located.
4.Execute the command "corflags /32BIT+ /FORCE WcfSvcHost.exe"
5.Copy the files back to where you found it.
 
Now your WcfSvcHost and WcfTestClient will be running in 32 bit mode.

Omnext was part of a Dutch trade delegation visiting the New York CloudExpo 2011.
Here is a link to a great article by Theo Loth (coordinator EuroCloud Nederland) about the event: omnext - cloudexpo 2011.pdf (in Dutch).

If your looking to find out more about Omnext and how Source2VALUE can help improve the ROI of your software development investments, then visit www.omnext.net or talk to Jaco and Andre at the 2011 European Outsourcing Summit in Madrid, Spain.

For those who will be in the Netherlands in October: the SDN is organizing it’s annual 2-day conference on October 3rd and 4th, 2011. A preview of the schedule is now online and registration has just opened: http://www.sdn.nl/SDN/SDNEvent/SDNConferences2011/tabid/162/Default.aspx

A (short) video impression of Maine Code Camp #2:

Suppose I have a list of time cards from multiple employees, but I want to group them into dictionary, based on the Social Security Number (SSN) of the employee. Here is an example of how to convert a list of items into a dictionary of lists:

Dictionary<string, List<TimeCardInfo>>
dict;

dict = ( from timecard in listOfTimeCards

         group timecard by timecard.SSN ).ToDictionary( x => x.Key, x => x.ToList() );

In the model below the phone number for an artist is actually a complex type (a little over engineered, I know, but I was just exploring how well this works).

The complex type consists of 4 ‘fields’: CountryCode, AreaCode, Number and Extension:

Each ‘field’ has properties set:

The great part is that this is fully supported by the DDL generator, so right click on the Entity Framework Designer in Visual Studio 2010 and choose ‘Generate Database From Model…’ and the ‘Artist’ table will be generated as:

              --
--------------------------------------------------
            

              --
Entity Designer DDL Script for SQL Server 2005, 2008, and Azure
            

              --
--------------------------------------------------
            

              --
--------------------------------------------------
            

              --
Creating all tables
            

              --
--------------------------------------------------
            

              --
Creating table 'Artists'
            

              CREATE
              TABLE [dbo].[Artists]
(

    [Id] intIDENTITY(1,1) NOTNULL,

    [Name] nvarchar(100)  NOTNULL,

    [IsIndividual] bitNOTNULL,

    [Phone_CountryCode] nvarchar(4)  NOTNULL,

    [Phone_AreaCode] nvarchar(5)  NOTNULL,

    [Phone_Number] nvarchar(10)  NOTNULL,

    [Phone_Extension] nvarchar(10)  NULL

);

              GO
            

              --
<snip other tables>
            

              --
--------------------------------------------------
            

              --
Creating all PRIMARY KEY constraints
            

              --
--------------------------------------------------
            

              --
Creating primary key on [Id] in table 'Artists'
            

              ALTER
              TABLE [dbo].[Artists]

              ADD
              CONSTRAINT [PK_Artists]

              PRIMARY
              KEY
              CLUSTERED ([Id] ASC);

              GO
            

              --
<snip other primary and foreign key>
            

              --
--------------------------------------------------
            

              --
Script has ended
            

-- --------------------------------------------------

If you’re using the Entity Framework and don’t want to implement ToTraceString() at strategic points in your code in order to see what kind of SQL statements are getting generated then check out one of the following:

• Community Entity Framework Provider Wrappers (free)
  • http://efwrappers.codeplex.com/
  • Or use NuGet:
    • Install-Package CommunityEFProviderWrappers.EFTracingProvider
• Entity Framework Profiler
• http://efprof.com/
• SQL Server Profiler
• More info on setting up SQL Server Profiler: http://blog.tonysneed.com/2010/08/05/setting-up-sql-server-2008-express-with-profiler

Update 07-02-2011: Added SQL Server Profiler after comment by Tony Sneed.

If you’re doing Model First with Entity Framework you may run into a scenario where you want to design a 1-to-1 relationship, but also have a foreign key be available on your entity. The default behavior in Entity Framework when doing a 1-to-1 relationship (with Model First), or 1-to-0..1 relationship, is to create a foreign key on the 0..1 side of the association but hide the foreign key. A better approach is this:

• Start a new model
• Add the entity that goes on the 1 side of the association, give it a primary key of type integer. Make sure the StoreGeneratedPattern property is set to Identity.
• Add the entity that goes on the 0..1 side of the assocation, name the primary key as you would a foreign key, make it of type integer. Make sure the StoreGeneratedPattern property is set to None.
  
• Click on the 1 entity and add an association, make it a 1-to-0..1, example:
  
• Double click the association and set a referential constraint.
  
• Now you’re ready to generate your database schema.