Extending Visual Studio Context Menus

by mark shiffer 19. July 2010 23:29

Just a few quick things that I learned while trying to create a new context menu item on the solution explorer in visual studio:

First, there is a post on how to enable VSIP Logging that comes in handy to figure out the Guids and Ids of the menu items in visual studio. The full post is: Using EnableVSIPLogging to identify menus and commands with VS 2005 + SP1, but this part applies to Visual Studio 2010 as well. Essentially you flip a flag in the registry, restart Visual Studio and then using Ctrl-Shift, Right Click on menu items and a dialog appears with the information that you need. Here is the registry key:
[HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\8.0\General]
"EnableVSIPLogging"=dword:00000001

Second, from an article entitled Dynamic Menu Command in Visual Studio Packages – Part 2, which is where I found the first reference from, it shows how to define a GuidSymbol, Group and Button appropriately. I am not going to repeat that here. Really it is just repeating what Visual Studio does for you automatically when you create a Package.

6a0b0263-8d1a-44d9-9a35-7b38a1120aa5|0|.0

Tags:

Fun Coding Challenges

by mark shiffer 16. July 2010 17:03

Pex is an automated unit testing generation tool that Microsoft Research has had out for a while now. Essentially Pex generates various input parameters for your methods helping to find the variations that should be testing to get good code coverage.

The PexForFun website provides an interesting set of code challenges while using Pex to drive it. You are given a starter method that is stripped down to be barely functional and that fails the Pex generated tests. Your goal is to alter the method such that it will pass the tests without any outside knowledge as to what the code is supposed to do and without knowing the Pex unit tests until they fail. It is an interesting approach to advertising what capabilities Pex has and can be a little addicting too.

6a4acedb-64e5-4443-87b1-73daeb46872a|0|.0

Tags:

Research | Programming

Development Resources for Any Language!

by mark shiffer 16. July 2010 16:56

Came across a website today called DevCheatSheet that contains a nice compilation of quick references for just about any language (and more) you can think of including: programming, scripting, markup, databases, version control, servers, ORM, blogs, websites, text editors and many other miscellaneous application.

Although fairly comprehensive there are missing pieces. I noticed Team Foundation Server (TFS) was missing from version control and Entity Framework (EF) was missing from ORM. Regardless should be a good place to find a reference for that language that you rarely use and need to remind your self of the syntax for.

de9cf9db-1fc6-446e-8e48-ed6d71a37a57|0|.0

Tags:

Programming | Research

Examining Entity Framework’s SQL Generation

by mark shiffer 30. June 2010 16:00

I am just getting started with this, but so far I am less than impressed with the SQL that is being generated by Entity Framework. The following is an example of a query that is generated by Entity Framework for a system that I am currently working on.

        1: SELECT 

       2: [UnionAll4].[C2] AS [C1], 

       3: ...

       4: [UnionAll4].[C590] AS [C590]

       5: FROM  (SELECT 

       6:     [UnionAll2].[C1] AS [C1], 

       7:         ...

       8:     [UnionAll2].[C590] AS [C590]

       9:     FROM  (SELECT 

        [UnionAll1].[C1] AS [C1], 

        ...

        [UnionAll1].[C547] AS [C590]

        FROM  (SELECT 

            CASE WHEN ([Extent5].[Id] IS NULL) THEN CAST(NULL AS int) ELSE 1 END AS [C1], 

            [Extent2].[Id] AS [Id], 

            [Extent3].[Id] AS [Id1], 

            0 AS [C2], 

            '0X0X0X0X' AS [C3], 

            0 AS [C4], 

            [Extent1].[Id] AS [Id2], 

            [Extent1].[ModifiedBy] AS [ModifiedBy], 

            [Extent1].[LastModified] AS [LastModified], 

            [Extent1].[TaxId] AS [TaxId], 

            [Extent1].[Version] AS [Version], 

            [Extent2].[LastName] AS [LastName], 

            [Extent2].[FirstName] AS [FirstName], 

            [Extent2].[BirthDate] AS [BirthDate], 

            [Extent2].[MiddleName] AS [MiddleName], 

            [Extent2].[Gender] AS [Gender], 

            [Extent2].[PreferredName] AS [PreferredName], 

            [Extent3].[SrsStartDate] AS [SrsStartDate], 

            [Extent3].[VacationBaseDate] AS [VacationBaseDate], 

            [Extent3].[CredibleServiceDate] AS [CredibleServiceDate], 

            [Extent3].[ContinuousServiceDate] AS [ContinuousServiceDate], 

            [Extent3].[TerminationDate] AS [TerminationDate], 

            [Extent3].[MonthlySalary] AS [MonthlySalary], 

            [Extent3].[PayStep] AS [PayStep], 

            [Extent3].[IsMeritComp] AS [IsMeritComp], 

            [Extent3].[SeniorityDate] AS [SeniorityDate], 

            [Extent3].[WorkScheduleTypeId] AS [WorkScheduleTypeId], 

            [Extent3].[SupervisorEmployeeId] AS [SupervisorEmployeeId], 

            CAST(NULL AS varchar(1)) AS [C5], 

            CAST(NULL AS varchar(1)) AS [C6], 

            CAST(NULL AS varchar(1)) AS [C7], 

            CAST(NULL AS uniqueidentifier) AS [C8], 

            CAST(NULL AS uniqueidentifier) AS [C9], 

            CAST(NULL AS varbinary(1)) AS [C10], 

            CAST(NULL AS varchar(1)) AS [C11], 

            CAST(NULL AS varchar(1)) AS [C12], 

            CAST(NULL AS varchar(1)) AS [C13], 

            CAST(NULL AS varchar(1)) AS [C14], 

            CAST(NULL AS uniqueidentifier) AS [C15], 

            CAST(NULL AS uniqueidentifier) AS [C16], 

            ...

            CAST(NULL AS varbinary(1)) AS [C53], 

            CASE WHEN ([Extent4].[Id] IS NULL) THEN CAST(NULL AS varchar(1)) ELSE '0X3X' END AS [C54], 

            CASE WHEN ([Extent4].[Id] IS NULL) THEN CAST(NULL AS int) ELSE 4 END AS [C55], 

            [Extent4].[Id] AS [Id3], 

            [Extent4].[ModifiedBy] AS [ModifiedBy1], 

            [Extent4].[LastModified] AS [LastModified1], 

            CAST(NULL AS varchar(1)) AS [C56], 

            ...

            CAST(NULL AS varbinary(1)) AS [C89], 

            [Extent4].[Sequence] AS [Sequence], 

            [Extent4].[TitleId] AS [TitleId], 

            [Extent4].[AgencyId] AS [AgencyId], 

            [Extent4].[SectionId] AS [SectionId], 

            [Extent4].[EqualEmploymentOpportunityCodeId] AS [EqualEmploymentOpportunityCodeId], 

            [Extent4].[BargainingUnitCodeId] AS [BargainingUnitCodeId], 

            [Extent4].[Version] AS [Version1], 

            CAST(NULL AS datetime2) AS [C90], 

            ...

            CAST(NULL AS varbinary(1)) AS [C116], 

            CASE WHEN ([Extent5].[Id] IS NULL) THEN CAST(NULL AS varchar(1)) ELSE '0X1X' END AS [C117], 

            CASE WHEN ([Extent5].[Id] IS NULL) THEN CAST(NULL AS int) ELSE 5 END AS [C118], 

            [Extent5].[Id] AS [Id4], 

            [Extent5].[ModifiedBy] AS [ModifiedBy2], 

            [Extent5].[LastModified] AS [LastModified2], 

            CAST(NULL AS varchar(1)) AS [C119], 

            ...

            CAST(NULL AS uniqueidentifier) AS [C137], 

            [Extent5].[CountryCode] AS [CountryCode], 

            ...

            CAST(NULL AS varbinary(1)) AS [C547]

            FROM     [dbo].[Orgsons] AS [Extent1]

            INNER JOIN [dbo].[Orgsons_Person] AS [Extent2] ON [Extent1].[Id] = [Extent2].[Id]

            INNER JOIN [dbo].[Orgsons_Employee] AS [Extent3] ON [Extent1].[Id] = [Extent3].[Id]

            LEFT OUTER JOIN [dbo].[Positions] AS [Extent4] ON [Extent3].[Position_Id] = [Extent4].[Id]

            LEFT OUTER JOIN [dbo].[PhoneNumbers] AS [Extent5] ON [Extent1].[Id] = [Extent5].[OrgsonId]

            WHERE [Extent1].[Id] = '4F65BC85-06FD-4CC7-BB2B-95F2536EF132'

        UNION ALL

            SELECT 

            2 AS [C1], 

            [Extent7].[Id] AS [Id], 

            [Extent8].[Id] AS [Id1], 

            0 AS [C2], 

            '0X0X0X0X' AS [C3], 

            0 AS [C4], 

            [Extent6].[Id] AS [Id2], 

            [Extent6].[ModifiedBy] AS [ModifiedBy], 

            [Extent6].[LastModified] AS [LastModified], 

            [Extent6].[TaxId] AS [TaxId], 

            [Extent6].[Version] AS [Version], 

            [Extent7].[LastName] AS [LastName], 

            [Extent7].[FirstName] AS [FirstName], 

            [Extent7].[BirthDate] AS [BirthDate], 

            [Extent7].[MiddleName] AS [MiddleName], 

            [Extent7].[Gender] AS [Gender], 

            [Extent7].[PreferredName] AS [PreferredName], 

            [Extent8].[SrsStartDate] AS [SrsStartDate], 

            [Extent8].[VacationBaseDate] AS [VacationBaseDate], 

            [Extent8].[CredibleServiceDate] AS [CredibleServiceDate], 

            [Extent8].[ContinuousServiceDate] AS [ContinuousServiceDate], 

            [Extent8].[TerminationDate] AS [TerminationDate], 

            [Extent8].[MonthlySalary] AS [MonthlySalary], 

            [Extent8].[PayStep] AS [PayStep], 

            [Extent8].[IsMeritComp] AS [IsMeritComp], 

            [Extent8].[SeniorityDate] AS [SeniorityDate], 

            [Extent8].[WorkScheduleTypeId] AS [WorkScheduleTypeId], 

            [Extent8].[SupervisorEmployeeId] AS [SupervisorEmployeeId], 

            CAST(NULL AS varchar(1)) AS [C5], 

            ...

            CAST(NULL AS varbinary(1)) AS [C53], 

            CASE WHEN ([Extent9].[Id] IS NULL) THEN CAST(NULL AS varchar(1)) ELSE '0X3X' END AS [C54], 

            CASE WHEN ([Extent9].[Id] IS NULL) THEN CAST(NULL AS int) ELSE 4 END AS [C55], 

            [Extent9].[Id] AS [Id3], 

            [Extent9].[ModifiedBy] AS [ModifiedBy1], 

            [Extent9].[LastModified] AS [LastModified1], 

            CAST(NULL AS varchar(1)) AS [C56], 

            ...

            CAST(NULL AS varbinary(1)) AS [C89], 

            [Extent9].[Sequence] AS [Sequence], 

            [Extent9].[TitleId] AS [TitleId], 

            [Extent9].[AgencyId] AS [AgencyId], 

            [Extent9].[SectionId] AS [SectionId], 

            [Extent9].[EqualEmploymentOpportunityCodeId] AS [EqualEmploymentOpportunityCodeId], 

            [Extent9].[BargainingUnitCodeId] AS [BargainingUnitCodeId], 

            [Extent9].[Version] AS [Version1], 

            CAST(NULL AS datetime2) AS [C90], 

            ...

            CAST(NULL AS varbinary(1)) AS [C216], 

            [Extent10].[Street1] AS [Street1], 

            [Extent10].[Street2] AS [Street2], 

            [Extent10].[City] AS [City], 

            [Extent10].[ZipCode] AS [ZipCode], 

            [Extent10].[OrgsonId] AS [OrgsonId], 

            [Extent10].[AddressTypeId] AS [AddressTypeId], 

            [Extent10].[StateId] AS [StateId], 

            [Extent10].[CountryId] AS [CountryId], 

            [Extent10].[Version] AS [Version2], 

            CAST(NULL AS varchar(1)) AS [C217], 

            ... 

            CAST(NULL AS varbinary(1)) AS [C544]

            FROM     [dbo].[Orgsons] AS [Extent6]

            INNER JOIN [dbo].[Orgsons_Person] AS [Extent7] ON [Extent6].[Id] = [Extent7].[Id]

            INNER JOIN [dbo].[Orgsons_Employee] AS [Extent8] ON [Extent6].[Id] = [Extent8].[Id]

            LEFT OUTER JOIN [dbo].[Positions] AS [Extent9] ON [Extent8].[Position_Id] = [Extent9].[Id]

            INNER JOIN [dbo].[Addresses] AS [Extent10] ON [Extent6].[Id] = [Extent10].[OrgsonId]

            WHERE [Extent6].[Id] = '4F65BC85-06FD-4CC7-BB2B-95F2536EF132') AS [UnionAll1]

    UNION ALL

        SELECT 

        3 AS [C1], 

        [Extent12].[Id] AS [Id], 

        [Extent13].[Id] AS [Id1], 

        0 AS [C2], 

        '0X0X0X0X' AS [C3], 

        0 AS [C4], 

        [Extent11].[Id] AS [Id2], 

        [Extent11].[ModifiedBy] AS [ModifiedBy], 

        [Extent11].[LastModified] AS [LastModified], 

        [Extent11].[TaxId] AS [TaxId], 

        [Extent11].[Version] AS [Version], 

        [Extent12].[LastName] AS [LastName], 

        [Extent12].[FirstName] AS [FirstName], 

        [Extent12].[BirthDate] AS [BirthDate], 

        [Extent12].[MiddleName] AS [MiddleName], 

        [Extent12].[Gender] AS [Gender], 

        [Extent12].[PreferredName] AS [PreferredName], 

        [Extent13].[SrsStartDate] AS [SrsStartDate], 

        [Extent13].[VacationBaseDate] AS [VacationBaseDate], 

        [Extent13].[CredibleServiceDate] AS [CredibleServiceDate], 

        [Extent13].[ContinuousServiceDate] AS [ContinuousServiceDate], 

        [Extent13].[TerminationDate] AS [TerminationDate], 

        [Extent13].[MonthlySalary] AS [MonthlySalary], 

        [Extent13].[PayStep] AS [PayStep], 

        [Extent13].[IsMeritComp] AS [IsMeritComp], 

        [Extent13].[SeniorityDate] AS [SeniorityDate], 

        [Extent13].[WorkScheduleTypeId] AS [WorkScheduleTypeId], 

        [Extent13].[SupervisorEmployeeId] AS [SupervisorEmployeeId], 

        CAST(NULL AS varchar(1)) AS [C5], 

        ...

        CAST(NULL AS varbinary(1)) AS [C53], 

        CASE WHEN ([Extent14].[Id] IS NULL) THEN CAST(NULL AS varchar(1)) ELSE '0X3X' END AS [C54], 

        CASE WHEN ([Extent14].[Id] IS NULL) THEN CAST(NULL AS int) ELSE 4 END AS [C55], 

        [Extent14].[Id] AS [Id3], 

        [Extent14].[ModifiedBy] AS [ModifiedBy1], 

        [Extent14].[LastModified] AS [LastModified1], 

        CAST(NULL AS varchar(1)) AS [C56], 

        ...

        CAST(NULL AS varbinary(1)) AS [C89], 

        [Extent14].[Sequence] AS [Sequence], 

        [Extent14].[TitleId] AS [TitleId], 

        [Extent14].[AgencyId] AS [AgencyId], 

        [Extent14].[SectionId] AS [SectionId], 

        [Extent14].[EqualEmploymentOpportunityCodeId] AS [EqualEmploymentOpportunityCodeId], 

        [Extent14].[BargainingUnitCodeId] AS [BargainingUnitCodeId], 

        [Extent14].[Version] AS [Version1], 

        CAST(NULL AS datetime2) AS [C90], 

        ...

        CAST(NULL AS varbinary(1)) AS [C262], 

        '0X4X' AS [C263], 

        10 AS [C264], 

        [Extent15].[Id] AS [Id4], 

        [Extent15].[ModifiedBy] AS [ModifiedBy2], 

        [Extent15].[LastModified] AS [LastModified2], 

        CAST(NULL AS varchar(1)) AS [C265], 

        ...

        CAST(NULL AS varbinary(1)) AS [C305], 

        [Extent15].[SentDate] AS [SentDate], 

        [Extent15].[ReturnedDate] AS [ReturnedDate], 

        [Extent15].[EmployeeId] AS [EmployeeId], 

        [Extent15].[EvaluationTypeId] AS [EvaluationTypeId], 

        [Extent15].[Version] AS [Version2], 

        CAST(NULL AS datetime2) AS [C306], 

        ...

        CAST(NULL AS varbinary(1)) AS [C548]

        FROM     [dbo].[Orgsons] AS [Extent11]

        INNER JOIN [dbo].[Orgsons_Person] AS [Extent12] ON [Extent11].[Id] = [Extent12].[Id]

        INNER JOIN [dbo].[Orgsons_Employee] AS [Extent13] ON [Extent11].[Id] = [Extent13].[Id]

        LEFT OUTER JOIN [dbo].[Positions] AS [Extent14] ON [Extent13].[Position_Id] = [Extent14].[Id]

        INNER JOIN [dbo].[Evaluations] AS [Extent15] ON [Extent11].[Id] = [Extent15].[EmployeeId]

        WHERE [Extent11].[Id] = '4F65BC85-06FD-4CC7-BB2B-95F2536EF132') AS [UnionAll2]

UNION ALL

    SELECT 

    4 AS [C1], 

    [Project6].[Id1] AS [Id], 

    [Project6].[Id2] AS [Id1], 

    [Project6].[C2] AS [C2], 

    [Project6].[C1] AS [C3], 

    [Project6].[C2] AS [C4], 

    [Project6].[Id] AS [Id2], 

    [Project6].[ModifiedBy] AS [ModifiedBy], 

    [Project6].[LastModified] AS [LastModified], 

    [Project6].[TaxId] AS [TaxId], 

    [Project6].[Version] AS [Version], 

    [Project6].[LastName] AS [LastName], 

    [Project6].[FirstName] AS [FirstName], 

    [Project6].[BirthDate] AS [BirthDate], 

    [Project6].[MiddleName] AS [MiddleName], 

    [Project6].[Gender] AS [Gender], 

    [Project6].[PreferredName] AS [PreferredName], 

    [Project6].[SrsStartDate] AS [SrsStartDate], 

    [Project6].[VacationBaseDate] AS [VacationBaseDate], 

    [Project6].[CredibleServiceDate] AS [CredibleServiceDate], 

    [Project6].[ContinuousServiceDate] AS [ContinuousServiceDate], 

    [Project6].[TerminationDate] AS [TerminationDate], 

    [Project6].[MonthlySalary] AS [MonthlySalary], 

    [Project6].[PayStep] AS [PayStep], 

    [Project6].[IsMeritComp] AS [IsMeritComp], 

    [Project6].[SeniorityDate] AS [SeniorityDate], 

    [Project6].[WorkScheduleTypeId] AS [WorkScheduleTypeId], 

    [Project6].[SupervisorEmployeeId] AS [SupervisorEmployeeId], 

    [Project6].[C3] AS [C5], 

    ...

    [Project6].[Id3] AS [Id3], 

    [Project6].[ModifiedBy1] AS [ModifiedBy1], 

    [Project6].[LastModified1] AS [LastModified1], 

    [Project6].[C54] AS [C56], 

    ... 

    [Project6].[C86] AS [C88], 

    [Project6].[C87] AS [C89], 

    [Project6].[Sequence] AS [Sequence], 

    [Project6].[TitleId] AS [TitleId], 

    [Project6].[AgencyId] AS [AgencyId], 

    [Project6].[SectionId] AS [SectionId], 

    [Project6].[EqualEmploymentOpportunityCodeId] AS [EqualEmploymentOpportunityCodeId], 

    [Project6].[BargainingUnitCodeId] AS [BargainingUnitCodeId], 

    [Project6].[Version1] AS [Version1], 

    [Project6].[C88] AS [C90], 

    ...     

    CAST(NULL AS varbinary(1)) AS [C335], 

    ...

    [UnionAll3].[C199] AS [C556]

    FROM   (SELECT 

        [Extent16].[Id] AS [Id], 

        [Extent16].[TaxId] AS [TaxId], 

        [Extent16].[Version] AS [Version], 

        [Extent16].[ModifiedBy] AS [ModifiedBy], 

        [Extent16].[LastModified] AS [LastModified], 

        [Extent17].[LastName] AS [LastName], 

        [Extent17].[FirstName] AS [FirstName], 

        [Extent17].[BirthDate] AS [BirthDate], 

        [Extent17].[MiddleName] AS [MiddleName], 

        [Extent17].[Gender] AS [Gender], 

        [Extent17].[PreferredName] AS [PreferredName], 

        [Extent17].[Id] AS [Id1], 

        [Extent18].[SrsStartDate] AS [SrsStartDate], 

        [Extent18].[VacationBaseDate] AS [VacationBaseDate], 

        [Extent18].[CredibleServiceDate] AS [CredibleServiceDate], 

        [Extent18].[ContinuousServiceDate] AS [ContinuousServiceDate], 

        [Extent18].[TerminationDate] AS [TerminationDate], 

        [Extent18].[MonthlySalary] AS [MonthlySalary], 

        [Extent18].[PayStep] AS [PayStep], 

        [Extent18].[IsMeritComp] AS [IsMeritComp], 

        [Extent18].[SeniorityDate] AS [SeniorityDate], 

        [Extent18].[WorkScheduleTypeId] AS [WorkScheduleTypeId], 

        [Extent18].[SupervisorEmployeeId] AS [SupervisorEmployeeId], 

        [Extent18].[Id] AS [Id2], 

        '0X0X0X0X' AS [C1], 

        0 AS [C2], 

        CAST(NULL AS varchar(1)) AS [C3], 

        ... 

        CAST(NULL AS varbinary(1)) AS [C51], 

        [Extent19].[Id] AS [Id3], 

        [Extent19].[Sequence] AS [Sequence], 

        [Extent19].[TitleId] AS [TitleId], 

        [Extent19].[AgencyId] AS [AgencyId], 

        [Extent19].[SectionId] AS [SectionId], 

        [Extent19].[EqualEmploymentOpportunityCodeId] AS [EqualEmploymentOpportunityCodeId], 

        [Extent19].[BargainingUnitCodeId] AS [BargainingUnitCodeId], 

        [Extent19].[Version] AS [Version1], 

        [Extent19].[ModifiedBy] AS [ModifiedBy1], 

        [Extent19].[LastModified] AS [LastModified1], 

        CASE WHEN ([Extent19].[Id] IS NULL) THEN CAST(NULL AS varchar(1)) ELSE '0X3X' END AS [C52], 

        CASE WHEN ([Extent19].[Id] IS NULL) THEN CAST(NULL AS int) ELSE 4 END AS [C53], 

        CAST(NULL AS varchar(1)) AS [C54], 

        ... 

        CAST(NULL AS varbinary(1)) AS [C114]

        FROM    [dbo].[Orgsons] AS [Extent16]

        INNER JOIN [dbo].[Orgsons_Person] AS [Extent17] ON [Extent16].[Id] = [Extent17].[Id]

        INNER JOIN [dbo].[Orgsons_Employee] AS [Extent18] ON [Extent16].[Id] = [Extent18].[Id]

        LEFT OUTER JOIN [dbo].[Positions] AS [Extent19] ON [Extent18].[Position_Id] = [Extent19].[Id]

        WHERE [Extent16].[Id] = '4F65BC85-06FD-4CC7-BB2B-95F2536EF132' ) AS [Project6]

    CROSS APPLY  (SELECT 

        CASE WHEN ([Extent21].[Id] IS NULL) THEN CAST(NULL AS int) ELSE 1 END AS [C1], 

        12 AS [C2], 

        '0X5X' AS [C3], 

        12 AS [C4], 

        [Extent20].[Id] AS [Id], 

        [Extent20].[ModifiedBy] AS [ModifiedBy], 

        [Extent20].[LastModified] AS [LastModified], 

        CAST(NULL AS varchar(1)) AS [C5], 

        ... 

        CAST(NULL AS varbinary(1)) AS [C61], 

        CASE WHEN ([Extent21].[Id] IS NULL) THEN CAST(NULL AS varchar(1)) ELSE '0X6X' END AS [C62], 

        CASE WHEN ([Extent21].[Id] IS NULL) THEN CAST(NULL AS int) ELSE 14 END AS [C63], 

        [Extent21].[Id] AS [Id1], 

        [Extent21].[ModifiedBy] AS [ModifiedBy1], 

        [Extent21].[LastModified] AS [LastModified1], 

        CAST(NULL AS varchar(1)) AS [C64], 

        ... 

        CAST(NULL AS varbinary(1)) AS [C120], 

        [Extent21].[Description] AS [Description], 

        [Extent21].[Created] AS [Created1], 

        [Extent21].[CreatedBy] AS [CreatedBy], 

        [Extent21].[LeaveOfAbsenceId] AS [LeaveOfAbsenceId], 

        [Extent21].[Version] AS [Version1], 

        CAST(NULL AS datetime2) AS [C121], 

        ... 

        CAST(NULL AS varbinary(1)) AS [C199]

        FROM  [dbo].[LeaveOfAbsences] AS [Extent20]

        LEFT OUTER JOIN [dbo].[Comments] AS [Extent21] ON [Extent20].[Id] = [Extent21].[LeaveOfAbsenceId]

        WHERE ([Project6].[C2] = 0) AND ([Project6].[Id] = [Extent20].[EmployeeId])

    UNION ALL

        SELECT 

        2 AS [C1], 

        12 AS [C2], 

        '0X5X' AS [C3], 

        12 AS [C4], 

        [Extent22].[Id] AS [Id], 

        [Extent22].[ModifiedBy] AS [ModifiedBy], 

        [Extent22].[LastModified] AS [LastModified], 

        CAST(NULL AS varchar(1)) AS [C5], 

        ... 

        CAST(NULL AS varbinary(1)) AS [C50], 

        [Extent22].[RequestReceivedDate] AS [RequestReceivedDate], 

        [Extent22].[PacketSentDate] AS [PacketSentDate], 

        [Extent22].[PacketReceivedDate] AS [PacketReceivedDate], 

        [Extent22].[ReviewSentDate] AS [ReviewSentDate], 

        [Extent22].[ReviewReceivedDate] AS [ReviewReceivedDate], 

        [Extent22].[ApprovedDate] AS [ApprovedDate], 

        [Extent22].[EmployeeId] AS [EmployeeId], 

        [Extent22].[Created] AS [Created], 

        [Extent22].[LeaveTypeId] AS [LeaveTypeId], 

        [Extent22].[LeaveStatusId] AS [LeaveStatusId], 

        [Extent22].[Version] AS [Version], 

        CAST(NULL AS varchar(1)) AS [C51], 

        ...

        CAST(NULL AS varbinary(1)) AS [C134], 

        '0X7X' AS [C135], 

        16 AS [C136], 

        [Extent23].[Id] AS [Id1], 

        [Extent23].[ModifiedBy] AS [ModifiedBy1], 

        [Extent23].[LastModified] AS [LastModified1], 

        CAST(NULL AS varchar(1)) AS [C137], 

        ... 

        CAST(NULL AS varbinary(1)) AS [C198], 

        [Extent23].[StartDate] AS [StartDate], 

        [Extent23].[StopDate] AS [StopDate], 

        [Extent23].[DaysOff] AS [DaysOff], 

        [Extent23].[Created] AS [Created1], 

        [Extent23].[LeaveOfAbsenceId] AS [LeaveOfAbsenceId], 

        [Extent23].[Version] AS [Version1]

        FROM  [dbo].[LeaveOfAbsences] AS [Extent22]

        INNER JOIN [dbo].[LeaveOutOfOffices] AS [Extent23] ON [Extent22].[Id] = [Extent23].[LeaveOfAbsenceId]

        WHERE ([Project6].[C2] = 0) AND ([Project6].[Id] = [Extent22].[EmployeeId])) AS [UnionAll3]) AS [UnionAll4]

ORDER BY [UnionAll4].[C2] ASC, [UnionAll4].[C3] ASC, [UnionAll4].[C7] ASC, [UnionAll4].[C80] ASC, [UnionAll4].[C1] ASC, [UnionAll4].[C373] ASC, [UnionAll4].[C444] ASC;

That amounts to almost 4800 lines of SQL (much of it repetitive and omitted above) for a simple retrieve of an employee by id with some related data! Wow, what can be said about that!

The following query does the same thing in about 20 lines and runs 3 times faster:

       1: SELECT 

       2:     * 

       3: FROM 

       4:     Orgsons_Employee e 

       5:         JOIN 

       6:     Orgsons_Person p ON (e.Id = p.Id) 

       7:         JOIN 

       8:     Orgsons o ON (o.Id = p.Id) 

       9:         LEFT JOIN 

      10:     PhoneNumbers pn ON (pn.OrgsonId = o.Id) 

      11:         LEFT JOIN 

      12:     Addresses a ON (a.OrgsonId = o.Id) 

      13:         LEFT JOIN 

      14:     Positions pos ON (e.Position_Id = pos.Id) 

      15:         LEFT JOIN 

      16:     Evaluations eval ON (eval.EmployeeId = e.Id) 

      17:         LEFT JOIN 

      18:     LeaveOfAbsences loa ON (loa.EmployeeId = e.Id) 

      19:         LEFT JOIN 

      20:     LeaveOutOfOffices loo ON (loo.LeaveOfAbsenceId = loa.Id) 

      21:         LEFT JOIN 

      22:     Comments c ON (c.LeaveOfAbsenceId = loa.Id) 

      23: WHERE 

      24:     e.Id = '4F65BC85-06FD-4CC7-BB2B-95F2536EF132';

The execution plan on SQL Server shows a drastic difference between the two. If I find any hidden tweaking options for this in Entity Framework I’ll update this post.

65910762-320c-4efe-9399-a55908946c16|0|.0

Tags: Entity Framework, SQL

Nifty Microsoft Internet Explorer Advertising

by mark shiffer 29. June 2010 20:49

I usually browse in Chrome, and recently came across this example of advertising for Microsoft Internet Explorer.

Although it is doubtful I’ll switch back to Internet Explorer in the near term, I found this form of automatically advertising for IE when you hit Microsoft pages from a browser other than IE is rather clever. If you open this same page in IE, you don’t see the banner at the top. Good job Microsoft! Very slick.

1b86ee99-185c-4bdc-980b-997ee6e54ab4|0|.0

Tags:

Unit of Work Pattern for Entity Framework 4 and Unity

by Mark Shiffer 28. June 2010 13:43

Continuing from my last post on the Repository pattern…here is some background.

I am in the process of bringing up a new architecture for a project that I am working on that uses MVVM with WPF, WCF, Unity and Entity Framework 4 with Self Tracking Entities. One of the foundational items that is necessary to create as part of this architecture is a Repository to abstract the data store. As a related item, a proper Unit of Work pattern needs to be instantiated in order to provide transactional boundaries for some of the data processes. I will focus on the Unit of Work in this post, for more information on my repository implementation please see my previous post.

Before I started designing my approach I read several different attempts by others at implementing these patterns. Some were better than others, but in the end no one approach seemed to be a best fit for my application. However, the heaviest influence on my design came from NCommon, a library that contains implementations of commonly used design patterns when developing applications. If you haven’t looked at NCommon before, I would suggest taking a gander as it has some interesting stuff. However, for my purposes, it introduced too much complexity by trying to be a generic framework that applied to several different technologies, whereas, directing my approach to my specific set of technologies (while still abstracting mind you), made the code much more straight forward.

With Entity Framework it naturally works out that the ObjectContext is the unit of work itself. The ObjectContext is already caching all of the data changes that occur during its lifetime and only commits those when asked. So, at the core of my Unit of Work implementation is the ObjectContext. I have defined an IUnitOfWork interface which the ObjectContext implements to further abstract the concept. After that there are 3 core classes involved in my implementation of Unit of Work:

1. UnitOfWorkScope – The purpose of this class is to provide a quick fluid interface to place a unit of work around a block of code. This is the core class that is used by the ‘outside’ world to create transactional code. It’s intended usage pattern is:

using (var scope = new UnitOfWorkScope())

{

    ...

    scope.Commit();

}

2. TransactionManager – The TransactionManager is in charge of placing a UnitOfWorkScope into a UnitOfWorkTransaction whether it be new or existing.

3. UnitOfWorkTransaction – This is the actual transaction that controls when, and if, work completed within a set of UnitOfWorkScopes will be committed to the data store. When a UnitOfWorkTransaction is instantiated it creates a new IUnitOfWork instance (ObjectContext) on which to act.

So the developer creates scopes, nesting additional scopes where needed or creating side-by-side scopes of a separate transactional boundary. When a scope is created, it asks the TransactionManager to be enlisted in a transaction. The TransactionManager finds or creates an UnitOfWorkTransaction and associates it with the UnitOfWorkScope. The UnitOfWorkTransaction then keeps a list of active scopes for the transaction. When any of the scopes is rolled back, the entire transaction is torn down. Once the last scope is committed, assuming no rollbacks have occurred, the UnitOfWorkTransaction flushes the IUnitOfWork effectively calling SaveChanges on the ObjectContext.

If you’ve read the Repository post prior to this, you may have noticed where unit of work was tied in making the process very seamless for the end developer. The CurrentObjectSet property of the repository class coordinates with the TransactionManager such that regardless of where the repository instance was created, it will join a transaction on the fly if one is active. In addition, ApplyChanges will only save to the data store if the repository instance is not under a transaction at that time.

So, let’s start with the interfaces for what set’s all of this up:

IUnitOfWork:

/// <summary>

 /// Unit of work interface. The EF ObjectContext serves as the unit of work. This interface provides a contract to interact with the EF ObjectContext

 /// as a unit of work.s

 /// </summary>

 public interface IUnitOfWork : IDisposable

 {

     /// <summary>

     /// Gets the context for this unit of work (EF Context serves as the actual unit of work).

     /// </summary>

     /// <value>The context.</value>

     ObjectContext Context { get; }

  

     /// <summary>

     /// Commits changes to the Context to the data store.

     /// </summary>

     void Flush();

  

     /// <summary>

     /// Rollbacks changes to the Context.

     /// </summary>

     void Rollback();

 }

IUnitOfWorkScope:

/// <summary>

/// Unit of work scope is the outward facing wrapper for developers to begin/enlist in a transaction. Scopes can be nested, in which case, once the last or outtermost

/// scope is committed then the unit of work will be flushed/committed. If any scope exists/disposes before committing it will be rolled back, and any

/// scopes upward in the chain will be rolled back as well. 

/// </summary>

public interface IUnitOfWorkScope : IDisposable

{

    /// <summary>

    /// Marks the scope committed, triggering the unit of work to commit if this is the outtermost scope.

    /// </summary>

    void Commit();

  

    /// <summary>

    /// Rollbacks this scope, triggering the unit of work to be rolled back.

    /// </summary>

    void Rollback();

}

ITransactionManager:

/// <summary>

/// The Transaction Manager holds a list of active, isolated transactions within the system and acts as the entry point for a new unit of work scope. 

/// </summary>

public interface ITransactionManager

{

    /// <summary>

    /// Gets the current EF context based upon the most recent transacion.

    /// </summary>

    /// <value>The current context.</value>

    ObjectContext CurrentContext { get; }

  

    /// <summary>

    /// Gets or sets the thread static operation context, the unique identifier for a wcf call across our system.

    /// </summary>

    /// <value>The operation context.</value>

    /// <param name="operationContext">The operation context.</param>

    Guid OperationContext { get; set; }

  

    /// <summary>

    /// Enlists a <see cref="UnitOfWorkScope"/> instance with the transaction manager, either beginning a new transaction or attaching to an existing transaction.

    /// </summary>

    /// <param name="scope">bool. True if the scope should be enlisted in a new transaction, else

    /// false if the scope should participate in the existing transaction when available</param>

    /// <param name="newTransaction">if set to <c>true</c> [new transaction].</param>

    /// <returns>

    /// Transcation created or assigned to the scope.

    /// </returns>

    IUnitOfWorkTransaction EnlistScope(IUnitOfWorkScope scope, bool newTransaction);

}

IUnitOfWorkTransaction:

/// <summary>

/// Unit Of Work Transaction keeps a list of active scopes for a given transaction and commits the unit of work if all scopes have been committed.

/// </summary>

public interface IUnitOfWorkTransaction : IDisposable

{

    /// <summary>

    /// Occurs when [transaction disposing].

    /// </summary>

    event EventHandler<EventArgs> TransactionDisposing;

  

    /// <summary>

    /// Gets the unit of work.

    /// </summary>

    /// <value>The unit of work.</value>

    IUnitOfWork UnitOfWork { get; }

  

    /// <summary>

    /// Gets a unique identifier for a series of related operations. Under WCF this is provided by its operation context which is unique for each call made to the service.

    /// </summary>

    /// <value>The operation context identifier.</value>

    Guid OperationContext { get; }

  

    /// <summary>

    /// Enlists the scope in the transaction

    /// </summary>

    /// <param name="scope">The scope.</param>

    void EnlistScope(IUnitOfWorkScope scope);

  

    /// <summary>

    /// Commits the scope, if this is the last scope that was enlisted, the unit of work will be flushed.

    /// </summary>

    /// <param name="scope">The scope.</param>

    void CommitScope(IUnitOfWorkScope scope);

  

    /// <summary>

    /// Rollbacks the scope, effectively rolling back the unit of work.

    /// </summary>

    /// <param name="scope">The scope.</param>

    void RollbackScope(IUnitOfWorkScope scope);

}

All pretty straight forward. The only special note here is the OperationContext. This is what helps to make the pattern work across threads. This is especially important with WCF involved, as each call to the server will be on its own thread. In addition, server job processes could spawn additional threads to perform their work and one would expect work completed on a child thread should join the transaction of its parent. I’ll talk more about this as we look at the implementations of the interfaces.

<UnitOfWork>:

/// <summary> Provide business logic for the MSSWCModelContainer class 

/// </summary>

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1063:ImplementIDisposableCorrectly", Justification = "Need interface with IDisposable so that code can call base disposable generically.")]

public partial class MSSWCModelContainer : IUnitOfWork

{

    /// <summary>

    /// Gets the context.

    /// </summary>

    /// <value>The context.</value>

    public ObjectContext Context

    {

        get { return this; }

    }

  

    /// <summary> Persists all updates to the data source with the specified <see cref="T:System.Data.Objects.SaveOptions"/>.

    /// </summary>

    /// <param name="options">A <see cref="T:System.Data.Objects.SaveOptions"/> value that determines the behavior of the operation.</param>

    /// <returns>

    /// The number of objects in an <see cref="F:System.Data.EntityState.Added"/>, <see cref="F:System.Data.EntityState.Modified"/>, or <see cref="F:System.Data.EntityState.Deleted"/> state when <see cref="M:System.Data.Objects.ObjectContext.SaveChanges"/> was called.

    /// </returns>

    /// <exception cref="T:System.Data.OptimisticConcurrencyException">An optimistic concurrency violation has occurred.</exception>

    public override int SaveChanges(SaveOptions options)

    {

        // Validate the state of each entity in the context

        // before SaveChanges can succeed.

        foreach (ObjectStateEntry entry in ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Modified))

        {

            if (!entry.IsRelationship)

            {

                if (entry.Entity is IValidatingEntity)

                {

                    ((IValidatingEntity)entry.Entity).Validate();

                }

  

                if (entry.Entity is ISrsEntity)

                {

                    ApplyLastModifiedInformation((ISrsEntity)entry.Entity);

                }

            }

        }

  

        List<IObjectWithChangeTracker> entitiesToReset = null;

  

        if ((options & SaveOptions.AcceptAllChangesAfterSave) == SaveOptions.AcceptAllChangesAfterSave)

        {

            var q = from entry in ObjectStateManager.GetObjectStateEntries(EntityState.Added | EntityState.Deleted | EntityState.Modified)

                    where entry.Entity is IObjectWithChangeTracker

                    select (IObjectWithChangeTracker)entry.Entity;

  

            entitiesToReset = q.ToList();

        }

  

        var result = base.SaveChanges(options);

  

        if (entitiesToReset != null)

        {

            foreach (var entity in entitiesToReset)

            {

                entity.AcceptChanges();

            }

        }

  

        return result;

    }

  

    /// <summary>

    /// Commits this instance.

    /// </summary>

    public void Flush()

    {

        this.SaveChanges();

    }

  

    /// <summary>

    /// Rollbacks this instance.

    /// </summary>

    public void Rollback()

    {

        // rolling back invalidates this object context for any future use, so dispose it.

        Dispose();

    }

  

    /// <summary>

    /// Writes the last modified date/time and user information to the entity.

    /// </summary>

    /// <param name="entity">Entity to apply last modified info to.</param>

    private static void ApplyLastModifiedInformation(ISrsEntity entity)

    {

        entity.LastModified = DateTime.Now;

        if (ServiceSecurityContext.Current != null)

        {

            entity.ModifiedBy = ServiceSecurityContext.Current.WindowsIdentity.Name;

        }

    }

}

Not much to see here, moving on… Ignore the nastiness of the SaveChanges call and the AcceptChanges loop. Once again, Entity Framework has some issues.

UnitOfWorkScope:

/// <summary>

/// Unit of work scope is the outward facing wrapper for developers to begin/enlist in a transaction. Scopes can be nested, in which case, once the last or outtermost

/// scope is committed then the unit of work will be flushed/committed. If any scope exists/disposes before committing it will be rolled back, and any

/// scopes upward in the chain will be rolled back as well.

/// </summary>

public class UnitOfWorkScope : IUnitOfWorkScope, IDisposable

{

    private bool disposed;

    private bool commitAttempted;

    private IUnitOfWorkTransaction transaction;

    private ITransactionManager transactionManager;

  

    /// <summary>

    /// Initializes a new instance of the <see cref="UnitOfWorkScope"/> class with the <see cref="System.Data.IsolationLevel.Serializable"/>

    /// transaction isolation level.

    /// </summary>

    public UnitOfWorkScope()

        : this(false)

    {

    }

  

    /// <summary>

    /// Initializes a new instance of the <see cref="UnitOfWorkScope"/> class.

    /// </summary>

    /// <param name="newTransaction">To create a new scope that does not enlist in an existing ambient

    /// <see cref="UnitOfWorkScope"/> or <see cref="TransactionScope"/>, specify new, otherwise specify false.</param>

    public UnitOfWorkScope(bool newTransaction)

    {

        transaction = TransactionManager.EnlistScope(this, newTransaction);

        transaction.TransactionDisposing += new EventHandler<EventArgs>(OnTransactionDisposing);

        ScopeStatus = UnitOfWorkScopeStatus.Active;

    }

  

    /// <summary>

    /// Initializes a new instance of the <see cref="UnitOfWorkScope"/> class and enlists in a specific existing transaction.

    /// </summary>

    /// <param name="transaction">The transaction to enlist the new scope in.</param>

    public UnitOfWorkScope(IUnitOfWorkTransaction transaction)

    {

        if (transaction != null)

        {

            this.transaction = transaction;

            transaction.EnlistScope(this);

            ScopeStatus = UnitOfWorkScopeStatus.Active;

            transaction.TransactionDisposing += new EventHandler<EventArgs>(OnTransactionDisposing);

        }

        else

        {

            // if the transaction wasn't specified then call the transaction manager to enlist the scope as it will find/create a transaction for the scope to attach to.

            transaction = TransactionManager.EnlistScope(this, false);

            ScopeStatus = UnitOfWorkScopeStatus.Active;

            transaction.TransactionDisposing += new EventHandler<EventArgs>(OnTransactionDisposing);

        }

    }

  

    /// <summary>

    /// Event fired when the scope is comitting.

    /// </summary>

    public event EventHandler<EventArgs> ScopeComitting;

  

    /// <summary>

    /// Event fired when the scope is rollingback.

    /// </summary>

    public event EventHandler<EventArgs> ScopeRollingback;

  

    /// <summary>

    /// Gets the current scope status.

    /// </summary>

    /// <value>The scope status.</value>

    public UnitOfWorkScopeStatus ScopeStatus

    {

        get;

        private set;

    }

  

    /// <summary>

    /// Gets the transaction manager.

    /// </summary>

    /// <value>The transaction manager.</value>

    private ITransactionManager TransactionManager

    {

        get

        {

            if (transactionManager == null)

            {

                transactionManager = ServiceLocator.Current.GetInstance<ITransactionManager>();

            }

  

            return transactionManager;

        }

    }

  

    /// <summary>

    /// Commits the current running transaction in the scope.

    /// </summary>

    public void Commit()

    {

        if (disposed)

        {

            throw new ObjectDisposedException("Cannot commit a disposed UnitOfWorkScope instance.");

        }

  

        commitAttempted = true;

  

        if (ScopeComitting != null)

        {

            ScopeComitting(this, EventArgs.Empty);

        }

  

        if (transaction != null)

        {

            transaction.CommitScope(this);

        }

  

        ScopeStatus = UnitOfWorkScopeStatus.Complete;

    }

  

    /// <summary>

    /// Rollback the unit of work.

    /// </summary>

    public void Rollback()

    {

        if (ScopeRollingback != null)

        {

            ScopeRollingback(this, EventArgs.Empty);

        }

  

        if (transaction != null)

        {

            transaction.RollbackScope(this);

        }

  

        ScopeStatus = UnitOfWorkScopeStatus.Complete;

    }

  

    /// <summary>

    /// Disposes off the <see cref="UnitOfWorkScope"/> insance.

    /// </summary>

    public void Dispose()

    {

        Dispose(true);

        GC.SuppressFinalize(this);

    }

  

    /// <summary>

    /// Disposes off the managed and un-managed resources used.

    /// </summary>

    /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>

    private void Dispose(bool disposing)

    {

        if (disposed)

        {

            return;

        }

  

        if (disposing)

        {

            try

            {

                if (!commitAttempted)

                {

                    Rollback();

                }

            }

            finally

            {

                ScopeComitting = null;

                ScopeRollingback = null;

                disposed = true;

            }

        }

    }

  

    /// <summary>

    /// Handles the TransactionDisposing event of the transaction control.

    /// </summary>

    /// <param name="sender">The source of the event.</param>

    /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>

    private void OnTransactionDisposing(object sender, EventArgs e)

    {

        transaction.TransactionDisposing -= new EventHandler<EventArgs>(OnTransactionDisposing);

        transaction = null;

        ScopeStatus = UnitOfWorkScopeStatus.Complete;

    }

}

Again pretty straight forward. The TransactionManager that the scope uses for enlisting is service located, eventually pulled from Unity. This is done to keep the usage scenario fluent, otherwise each time a scope is instantiated a TransactionManager would have to be found to inject into the scope. That would either result in a lot of calls to service location spread around the code, or in the Unity container being passed around. Both of which are undesirable.

Take note, too, that disposing a scope will automatically trigger a rollback unless the scope was explicitly committed prior to the disposal via a call to Commit(). Also note, that additional flexibility is provided via the constructor overloads, allowing a UnitOfWorkScope to explicitly begin a new transaction or to enlist in a specific existing transaction. The default behavior is to enlist in the existing ambient transaction if one exists, otherwise to create one.

TransactionManager:

/// <summary>

/// The Transaction Manager holds a list of active, isolated transactions within the system and acts as the entry point for a new unit of work scope. 

/// </summary>

public class TransactionManager : ITransactionManager, IDisposable

{

    /// <summary>

    /// Dictionary of operation contexts to transactions operating under that context

    /// </summary>

    private readonly Dictionary<Guid, List<IUnitOfWorkTransaction>> transactionLists = new Dictionary<Guid, List<IUnitOfWorkTransaction>>();

  

    [ThreadStatic]

    private static Guid operationContext;

  

    private bool disposed;

    private object transactionsLockObject = new object();

    private IUnitOfWorkTransactionFactory transactionFactory;

  

    /// <summary>

    /// Initializes a new instance of the <see cref="TransactionManager"/> class.

    /// </summary>

    /// <param name="transactionFactory">The transaction factory.</param>

    public TransactionManager(IUnitOfWorkTransactionFactory transactionFactory)

    {

        this.transactionFactory = transactionFactory;

    }

  

    /// <summary>

    /// Gets the current context of the most recent transaction's unit of work.

    /// </summary>

    /// <value>The current context.</value>

    public ObjectContext CurrentContext

    {

        get

        {

            if (CurrentTransaction != null)

            {

                return CurrentTransaction.UnitOfWork.Context;

            }

            else

            {

                return null;

            }

        }

    }

  

    /// <summary>

    /// Gets or sets the operation context that the current thread is running under.

    /// Transactions are tied to an operation context, so that additional scopes that join a transaction should only join if they belong to the same context.

    /// This value is currently being set in the AuthorizationPolicy so that each call to WCF tags its thread with a unique context. If new threads are spawned

    /// by processes, they must manually copy the operation context from the main thread to their sub-threads.

    /// </summary>

    /// <value>The operation context, unique per wcf call.</value>

    /// <param name="operationContext">The operation context.</param>

    public Guid OperationContext

    {

        get

        {

            return operationContext;

        }

  

        set

        {

            operationContext = value;

        }

    }

  

    /// <summary>

    /// Gets the most recent transaction.

    /// </summary>

    /// <value>The current transaction.</value>

    private IUnitOfWorkTransaction CurrentTransaction

    {

        get

        {

            lock (transactionsLockObject)

            {

                List<IUnitOfWorkTransaction> transactions;

                if (transactionLists.TryGetValue(OperationContext, out transactions))

                {

                    if (transactions.Count > 0)

                    {

                        return transactions[transactions.Count - 1];

                    }

                }

  

                return null;

            }

        }

    }

  

    /// <summary>

    /// Enlists a <see cref="UnitOfWorkScope"/> instance with the transaction manager.

    /// </summary>

    /// <param name="scope">bool. True if the scope should be enlisted in a new transaction, else

    /// false if the scope should participate in the existing transaction</param>

    /// <param name="newTransaction">if set to <c>true</c> [new transaction].</param>

    /// <returns>

    /// Transcation created or assigned to the scope.

    /// </returns>

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:Dispose objects before losing scope", Justification = "Managed outside of this scope.")]

    public IUnitOfWorkTransaction EnlistScope(IUnitOfWorkScope scope, bool newTransaction)

    {

        if (newTransaction || CurrentTransaction == null)

        {

            IUnitOfWorkTransaction transaction = transactionFactory.CreateUnitOfWorkTransaction(OperationContext);

            transaction.TransactionDisposing += OnTransactionDisposing;

  

            lock (transactionsLockObject)

            {

                transaction.EnlistScope(scope);

                List<IUnitOfWorkTransaction> transactions;

                if (!transactionLists.TryGetValue(OperationContext, out transactions))

                {

                    transactions = new List<IUnitOfWorkTransaction>();

                    transactionLists.Add(OperationContext, transactions);

                }

  

                transactions.Add(transaction);

            }

  

            return transaction;

        }

        else

        {

            CurrentTransaction.EnlistScope(scope);

            return CurrentTransaction;

        }

    }

  

    /// <summary>

    /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

    /// </summary>

    /// <filterpriority>2</filterpriority>

    public void Dispose()

    {

        Dispose(true);

        GC.SuppressFinalize(this);

    }

  

    /// <summary>

    /// Releases unmanaged and - optionally - managed resources

    /// </summary>

    /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>

    private void Dispose(bool disposing)

    {

        if (disposed)

        {

            return;

        }

  

        if (disposing)

        {

            lock (transactionsLockObject)

            {

                if (transactionLists != null && transactionLists.Count > 0)

                {

                    foreach (var kvp in transactionLists)

                    {

                        foreach (var transaction in kvp.Value)

                        {

                            transaction.TransactionDisposing -= OnTransactionDisposing;

                            transaction.Dispose();

                        }

                    }

  

                    transactionLists.Clear();

                }

            }

        }

  

        disposed = true;

    }

  

    /// <summary>

    /// Called when [transaction disposing].

    /// </summary>

    /// <param name="sender">The sender.</param>

    /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>

    private void OnTransactionDisposing(object sender, EventArgs e)

    {

        IUnitOfWorkTransaction transaction = sender as IUnitOfWorkTransaction;

        if (transaction != null)

        {

            transaction.TransactionDisposing -= OnTransactionDisposing;

            lock (transactionsLockObject)

            {

                List<IUnitOfWorkTransaction> transactions;

                if (transactionLists.TryGetValue(transaction.OperationContext, out transactions))

                {

                    if (transactions.Contains(transaction))

                    {

                        transactions.Remove(transaction);

                    }

                }

            }

        }

    }

It’s getting a little more interesting now. One TransactionManager will exist for the entire WCF service, requiring some coordination of the active transactions, especially when one thinks about the threading that is happening in the service. The private field transactionLists, tracks all open transactions by their OperationContext. The OperationContext is simply a Guid that is set at the very beginning of each Wcf Service call. Take special note that the context is marked as ThreadStatic, so that one instance of operationContext exists for each thread, even though there is only one instance of the TransactionManager for the service as a whole. If a job process instantiates child threads to complete its work, it is the responsibility of the coder at that time to carry the operation context through and to set it on the TransactionManager.

UnitOfWorkTransaction:

/// <summary>

/// Unit Of Work Transaction keeps a list of active scopes for a given transaction and commits the unit of work if all scopes have been committed.

/// </summary>

public class UnitOfWorkTransaction : IUnitOfWorkTransaction, IDisposable

{

    private bool disposed;

    private IUnitOfWork unitOfWork;

    private IList<IUnitOfWorkScope> attachedScopes = new List<IUnitOfWorkScope>();

    private object attachedScopesLock = new object();

  

    /// <summary>

    /// Initializes a new instance of the <see cref="UnitOfWorkTransaction"/> class.

    /// </summary>

    /// <param name="unitOfWorkFactory">The context factory; used to create a new unit of work instance.</param>

    /// <param name="operationContext">The operation context, a unique identifier for each WCF call in our system, stored in TransactionManager's thread static property.</param>

    public UnitOfWorkTransaction(IUnitOfWorkFactory unitOfWorkFactory, Guid operationContext)

    {

        if (unitOfWorkFactory == null)

        {

            throw new ArgumentNullException("unitOfWorkFactory");

        }

  

        this.unitOfWork = unitOfWorkFactory.CreateUnitOfWork();

  

        this.OperationContext = operationContext;

    }

  

    /// <summary>

    /// Raised when the transaction is disposing.

    /// </summary>

    public event EventHandler<EventArgs> TransactionDisposing;

  

    /// <summary>

    /// Gets the <see cref="IUnitOfWork"/> instance managed by the 

    /// <see cref="UnitOfWorkTransaction"/> instance.

    /// </summary>

    public IUnitOfWork UnitOfWork

    {

        get { return unitOfWork; }

    }

  

    /// <summary>

    /// Gets the thread id for the transaction. Transactions are tied to a thread, so that additional scopes that join a transaction should only join if they belong to the same thread.

    /// </summary>

    /// <value>The thread id.</value>

    public Guid OperationContext

    {

        get;

        private set;

    }

  

    /// <summary>

    /// Attaches a <see cref="UnitOfWorkScope"/> instance to the 

    /// <see cref="UnitOfWorkTransaction"/> instance.

    /// </summary>

    /// <param name="scope">The <see cref="UnitOfWorkScope"/> instance to attach.</param>

    public void EnlistScope(IUnitOfWorkScope scope)

    {

        if (scope == null)

        {

            throw new ArgumentNullException("scope");

        }

  

        if (!attachedScopes.Contains(scope))

        {

            lock (attachedScopesLock)

            {

                if (!attachedScopes.Contains(scope))

                {

                    attachedScopes.Add(scope);

                }

            }

        }

    }

  

    /// <summary>

    /// Callback executed when an enlisted scope has comitted.

    /// </summary>

    /// <param name="scope">The scope.</param>

    public void CommitScope(IUnitOfWorkScope scope)

    {

        if (disposed)

        {

            throw new ObjectDisposedException("The transaction attached to the scope has already been disposed.");

        }

  

        lock (attachedScopesLock)

        {

            if (!attachedScopes.Contains(scope))

            {

                throw new InvalidOperationException("The scope being comitted is not attached to the current transaction.");

            }

  

            attachedScopes.Remove(scope);

            if (attachedScopes.Count == 0)

            {

                try

                {

                    unitOfWork.Flush();

                }

                finally

                {

                    // Dispose the transaction after comitting.

                    Dispose();

                }

            }

        }

    }

  

    /// <summary>

    /// Callback executed when an enlisted scope is rolledback.

    /// </summary>

    /// <param name="scope">The scope.</param>

    public void RollbackScope(IUnitOfWorkScope scope)

    {

        if (disposed)

        {

            throw new ObjectDisposedException("The transaction attached to the scope has already been disposed.");

        }

  

        // dispose this transcation which will notify via TransactionDisposing all scopes that were attached that the 

        // transaction is being rolled back

        Dispose();

    }

  

    /// <summary>

    /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

    /// </summary>

    /// <filterpriority>2</filterpriority>

    public void Dispose()

    {

        Dispose(true);

        GC.SuppressFinalize(this);

    }

  

    /// <summary>

    /// Releases unmanaged and - optionally - managed resources

    /// </summary>

    /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>

    private void Dispose(bool disposing)

    {

        if (disposed)

        {

            return;

        }

  

        if (disposing)

        {

            // notify all who care that this transaction is done.

            if (TransactionDisposing != null)

            {

                TransactionDisposing(this, EventArgs.Empty);

            }

  

            // dispose of the unit of work since it was created for this transaction specifically

            if (unitOfWork != null)

            {

                unitOfWork.Dispose();

            }

  

            lock (attachedScopesLock)

            {

                attachedScopes.Clear();

                attachedScopes = null;

            }

  

            TransactionDisposing = null;

            unitOfWork = null;

            disposed = true;

        }

    }

}

Nothing surprising in this implementation given the previous discussion. The UnitOfWorkTransaction then keeps a list of active scopes for the transaction. When any of the scopes is rolled back, the entire transaction is torn down. Once the last scope is committed, assuming no roll backs have occurred, the UnitOfWorkTransaction flushes the IUnitOfWork effectively calling SaveChanges on the ObjectContext.

That’s it folks. I left out a few of the factor interfaces as they are just boring.

054d6f4e-b0a2-4de3-b6be-12b4af129d43|1|5.0

Tags: Unit of Work, Entity Framework 4, Unity

Programming

Repository Pattern with Entity Framework 4

by Mark Shiffer 28. June 2010 13:41

An original post for once! :-)

I am in the process of bringing up a new architecture for a project that I am working on that uses MVVM with WPF, WCF, Unity and Entity Framework 4 with Self Tracking Entities. One of the foundational items that is necessary to create as part of this architecture is a Repository to abstract the data store. As a related item, a proper Unit of Work pattern needs to be instantiated in order to provide transactional boundaries for some of the data processes. I will talk more about Unit of Work in my next post, but the following is what I came up with to implement the Repository pattern.

Before I started designing my approach I read several different attempts by others at implementing these patterns. Some were better than others, but in the end no one approach seemed to be a best fit for my application. However, the heaviest influence on my design came from NCommon, a library that contains implementations of commonly used design patterns when developing applications. If you haven’t looked at NCommon before, I would suggest taking a gander as it has some interesting stuff. However, for my purposes, it introduced too much complexity by trying to be a generic framework that applied to several different technologies, whereas, directing my approach to my specific set of technologies (while still abstracting mind you), made the code much more straight forward.

The Repository interface contains the standard set of Find methods that you would expect a repository to have using predicate Expressions in order to pass through to LINQ. This makes it extremely flexible and easy to use while still remaining type safe to call. In addition, two ApplyChanges methods are provided to allow for add, modify, deletes via Self-Tracking Entities, and a Refresh method to force an entity to re-load its values from the data store.

Repository Interface:

/// <summary>Base interface for all repositories 

/// </summary>

/// <typeparam name="T">Aggregate type the repository is serving</typeparam>

public interface IRepository<T> : IDisposable where T : class, IObjectWithChangeTracker

{

    /// <summary>

    /// Return the entire set of persisted items

    /// </summary>

    /// <param name="includes">Sub-entities to include.</param>

    /// <returns>Collection of all persisted items</returns>

    IList<T> FindAll(params string[] includes);

  

    /// <summary>

    /// The first element in source that passes the test in predicate

    /// </summary>

    /// <param name="predicate">The predicate.</param>

    /// <param name="includes">The includes.</param>

    /// <returns>The first element in source that passes the test in predicate.</returns>

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Intended")]

    T First(Expression<Func<T, bool>> predicate, params string[] includes);

  

    /// <summary>

    /// Gets the first element of a sequence, or a default value if the sequence

    /// contains no elements.

    /// </summary>

    /// <param name="predicate">The predicate.</param>

    /// <param name="includes">The includes.</param>

    /// <returns>Returns the first element of a sequence, or a default value if the sequence

    /// contains no elements.</returns>

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Intended")]

    T FirstOrDefault(Expression<Func<T, bool>> predicate, params string[] includes);

  

    /// <summary>

    /// Gets the single element of the input sequence.

    /// </summary>

    /// <param name="predicate">The predicate.</param>

    /// <param name="includes">The includes.</param>

    /// <returns>The single element of the input sequence.</returns>

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Intended"), System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1716:IdentifiersShouldNotMatchKeywords", MessageId = "Single", Justification = "Intended")]

    T Single(Expression<Func<T, bool>> predicate, params string[] includes);

  

    /// <summary>

    /// Gest a collection of all persisted items that pass the test in the predicate

    /// </summary>

    /// <param name="predicate">The predicate.</param>

    /// <param name="includes">The includes.</param>

    /// <returns>Collection of all persisted items that pass the test in the predicate</returns>

    [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures", Justification = "Intended")]

    IList<T> Find(Expression<Func<T, bool>> predicate, params string[] includes);

  

    /// <summary>

    /// Persist changes a single entity to storage

    /// </summary>

    /// <param name="toSave">Entity to save</param>

    void ApplyChanges(T toSave);

  

    /// <summary> Persist changes a set of entities to storage

    /// </summary>

    /// <param name="toSave">Collection of entities to save</param>

    void ApplyChanges(IEnumerable<T> toSave);

  

    /// <summary>

    /// Refreshes the specified entities from the data store.

    /// </summary>

    /// <param name="entities">The entities.</param>

    void Refresh(params T[] entities);

}

Two generic implementations are provided. In order to deal with how Entity Framework handles the hierarchy of an aggregate, we need to know about both the base type of the aggregate and the final concrete type. For example, if you have an Employee entity that descends from a person Entity, the ObjectSet in Entity Framework is retrieved via Person and the OfType<T>() method is used with the concrete type to get only Employee entities. So, Repository<BaseType> is provided as a quick way to access the repository when there is no hierarchy (BaseType=ConcreteType). Repository<BaseType, ConcreteType> is where the meat of the implementation is.

The majority of the class is self-explanatory from the code, just a couple of things to mention:

1. Object Sets – I customized the T4 template for the Entity Framework ObjectContext to include a GetObjectSet method. This method allows me to tap into the helper object sets that the context already contains in a generic manner and reuse them across the life of a context.

2. ApplyToContext – This method is a bit messy, frankly, because Entity Framework itself is a bit messy at times. The ApplyChanges method of the ObjectContext in Entity Framework only works when the entity you are trying to save was loaded from outside of the context, otherwise the changes are not recognized properly. So I make a call to TryGetObjectStateEntry to see if my entity was previously loaded and then call ChangeObjectState for a delete or ApplyCurrentValues for a modify based upon the Self Tracking Entities state.

Repository Implementation:

/// <summary>

/// Simple entity repository

/// </summary>

/// <typeparam name="BaseType">Base class type of entity being managed by the repository</typeparam>

[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.StyleCop.CSharp.MaintainabilityRules", "SA1402:FileMayOnlyContainASingleClass", Justification = "Makes sense in this circumstance.")]

public class Repository<BaseType> : Repository<BaseType, BaseType>

    where BaseType : class, IObjectWithChangeTracker

{

    /// <summary>

    /// Initializes a new instance of the <see cref="Repository&lt;BaseType&gt;"/> class.

    /// </summary>

    /// <param name="contextFactory">The context factory.</param>

    /// <param name="transactionManager">The transaction manager.</param>

    public Repository(IContextFactory contextFactory, ITransactionManager transactionManager)

        : base(contextFactory, transactionManager)

    {

    }

}

  

/// <summary>Base class for entity repositories 

/// </summary>

/// <typeparam name="BaseType">Base class type of entity being managed by the repository</typeparam>

/// <typeparam name="ConcreteType">Concrete (derived) class type of entity being managed by the repository</typeparam>

public class Repository<BaseType, ConcreteType> : IRepository<ConcreteType>, IDisposable

    where BaseType : class, IObjectWithChangeTracker

    where ConcreteType : class, BaseType

{

    private ITransactionManager transactionManager;

    private ObjectContext localContext;

    private bool disposed;

  

    // hide the context from descendants, they should not be able to get to a context directly if we can help it. They can get to it through the ObjectSet which

    // we can't hide, but make it difficult to keep the repository single focused.

    private IContextFactory contextFactory;

  

    /// <summary>

    /// Initializes a new instance of the <see cref="Repository{BaseType,ConcreteType}"/> class.

dding-right: 0px; font-family: 'Courier New', courier, monospace; direction: ltr; border-top-style: none; color: black; font-size: 8pt; border-left-style: none; overflow: visible; padding-top: 0px">  38:     /// </summary>

    /// <param name="contextFactory">Factory that generates ObjectContext objects.</param>

    /// <param name="transactionManager">The transaction manager.</param>

    public Repository(IContextFactory contextFactory, ITransactionManager transactionManager)

    {

        this.transactionManager = transactionManager;

        this.contextFactory = contextFactory;

    }

  

    /// <summary>

    /// Gets the object set to act on given the current transaction state

    /// </summary>

    /// <value>The current object set.</value>

    /// <returns>The ObjectSet to use for this repository</returns>

    protected ObjectSet<BaseType> CurrentObjectSet

    {

        get

        {

            // if currently in a transaction, then assume it's context, otherwise use a locally created one.

            ObjectContext context = TransactionManager != null ? TransactionManager.CurrentContext : null;

  

            // create a context and manage its life if we are not already under a transaction scope

            if (context == null)

            {

                if (localContext == null)

                {

                    localContext = contextFactory.CreateContext();

                }

  

                context = localContext;

            }

  

            return ((SrsModelContainer)context).GetObjectSet<BaseType>();

        }

    }

  

    /// <summary>

    /// Gets the transaction manager.

    /// </summary>

    /// <value>The transaction manager.</value>

    private ITransactionManager TransactionManager

    {

        get

        {

            return transactionManager;

        }

    }

  

    /// <summary>

    /// Gets the first element in source that passes the test in predicate.

    /// </summary>

    /// <param name="predicate">The predicate.</param>

    /// <param name="includes">The includes.</param>

    /// <returns>

    /// The first element in source that passes the test in predicate.

    /// </returns>

    public ConcreteType First(Expression<Func<ConcreteType, bool>> predicate, params string[] includes)

    {

        return GetObjectSet(includes).First(predicate);

    }

  

    /// <summary>

    /// Returns the first element of a sequence, or a default value if the sequence

    /// contains no elements

    /// </summary>

    /// <param name="predicate">The predicate.</param>

    /// <param name="includes">The includes.</param>

    /// <returns>Returns the first element of a sequence, or a default value if the sequence

    /// contains no elements.</returns>

    public ConcreteType FirstOrDefault(Expression<Func<ConcreteType, bool>> predicate, params string[] includes)

    {

        return GetObjectSet(includes).FirstOrDefault(predicate);

    }

  

    /// <summary>

    /// The single element of the input sequence

    /// </summary>

    /// <param name="predicate">The predicate.</param>

    /// <param name="includes">The includes.</param>

    /// <returns>The single element of the input sequence.</returns>

    public ConcreteType Single(Expression<Func<ConcreteType, bool>> predicate, params string[] includes)

    {

        return GetObjectSet(includes).Single(predicate);

    }

  

    /// <summary>

    /// Gets a collection of all persisted items that pass the test in the predicate

    /// </summary>

    /// <param name="predicate">The predicate.</param>

    /// <param name="includes">The includes.</param>

    /// <returns>Collection of all persisted items that pass the test in the predicate</returns>

    public IList<ConcreteType> Find(Expression<Func<ConcreteType, bool>> predicate, params string[] includes)

    {

        return GetObjectSet(includes).Where(predicate).ToList();

    }

  

    /// <summary>

    /// Gets a collection of all persisted items

    /// </summary>

    /// <param name="includes">Sub-entities to include.</param>

    /// <returns>Collection of all persisted items</returns>

    public virtual IList<ConcreteType> FindAll(params string[] includes)

    {

        return GetObjectSet(includes).ToList();

    }

  

    /// <summary>

    /// Applies the changes for a single entity to the context

    /// </summary>

    /// <param name="toSave">Modified entity to apply changes for.</param>

    public virtual void ApplyChanges(ConcreteType toSave)

    {

        ValidateAggregate(toSave);

  

        ApplyToContext(toSave);

  

        // if no current transaction, then save, otherwise it belongs to the unit of work scope

        if (TransactionManager == null || TransactionManager.CurrentContext == null)

        {

            GetObjectSet().Context.SaveChanges();

        }

    }

  

    /// <summary> Applies the changes for a collection of entities to the context

    /// </summary>

    /// <param name="toSave">Collection of modified entities to apply changes for.</param>

    public virtual void ApplyChanges(IEnumerable<ConcreteType> toSave)

    {

        foreach (var item in toSave)

        {

            ValidateAggregate(item);

  

            ApplyToContext(item);

        }

  

        // if no current transaction, then save, otherwise it belongs to the unit of work scope

        if (TransactionManager == null || TransactionManager.CurrentContext == null)

        {

            GetObjectSet().Context.SaveChanges();

        }

    }

  

    /// <summary>

    /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.

    /// </summary>

    public void Dispose()

    {

        this.Dispose(true);

        GC.SuppressFinalize(this);

    }

  

    /// <summary>

    /// Refreshes the specified entities from the data store.

    /// </summary>

    /// <param name="entities">The entities.</param>

    public void Refresh(params ConcreteType[] entities)

    {

        CurrentObjectSet.Context.Refresh(RefreshMode.StoreWins, entities);

    }

  

    /// <summary>

    /// Validates the specified record to save and throws ValidationException if condition is not met

    /// </summary>

    /// <param name="toSave">The record to save.</param>

    protected virtual void ValidateAggregate(ConcreteType toSave)

    {

        // no default implementation

    }

  

    /// <summary>

    /// Gets the object set.

    /// </summary>

    /// <param name="includes">The includes.</param>

    /// <returns>

    /// Object set with the specified dependent objects included.

    /// </returns>

    protected ObjectQuery<ConcreteType> GetObjectSet(params string[] includes)

    {

        var objectSet = CurrentObjectSet.OfType<ConcreteType>();

        foreach (var include in includes)

        {

            objectSet = objectSet.Include(include);

        }

  

        return objectSet;

    }

  

    /// <summary>

    /// Applies changes for the given entity to context.

    /// </summary>

    /// <param name="entityToSave">The entity to save.</param>

    protected void ApplyToContext(ConcreteType entityToSave)

    {

        // If the object toSave was an existing record loaded from the same context that we are attempting to save it back to 

        // then some special considerations are needed.

        ObjectStateEntry entityStateEntry;

        if (CurrentObjectSet.Context.ObjectStateManager.TryGetObjectStateEntry(entityToSave, out entityStateEntry))

        {

            object contextEntity = entityStateEntry.Entity;

  

            if (entityToSave.ChangeTracker.State == ObjectState.Deleted)

            {

                // it's possible to have a different reference to the same entity (entity keys are the same). This will cause an error

                // when trying to delete, so we need to make sure that we are deleting the entity that is already in the store.

                CurrentObjectSet.Context.ObjectStateManager.ChangeObjectState(contextEntity, EntityState.Deleted);

            }

            else if (entityToSave.ChangeTracker.State == ObjectState.Modified)

            {

                // if the entity already in the store is not the same reference as the entity we are trying to save (even though they represent the same record in the store)

                // we need to move the changes over to the record already in the store. If they are the same, the changes are already there.                        

                if (!object.ReferenceEquals(contextEntity, entityToSave))

                {

                    CurrentObjectSet.Context.ApplyCurrentValues(CurrentObjectSet.EntitySet.Name, entityToSave);

                }

            }

        }

        else

        {

            // Apply changes only works when the object toSave does not already have a reference in the context's ObjectStateManager

            CurrentObjectSet.ApplyChanges(entityToSave);

        }

    }

  

    /// <summary>

    /// Releases unmanaged and - optionally - managed resources

    /// </summary>

    /// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>

    private void Dispose(bool disposing)

    {

        if (disposed)

        {

            return;

        }

  

        if (disposing)

        {

            if (localContext != null)

            {

                localContext.Dispose();

            }

        }

  

        disposed = true;

    }

}

That’s it. Next time we’ll look at the Unit of Work Pattern implementation that I came up with which is a bit more involved than the Repository.

1ab3d4c9-64db-4e48-a404-1cf29d218061|1|5.0

Tags: Repository, Entity Framework 4

Programming

IntelliSense for PowerShell

by mark shiffer 22. June 2010 14:00

CodePlex - PowerGUI Visual Studio Extension

Project Description
The PowerGUI Visual Studio Extension adds PowerShell IntelliSense support to Visual Studio.
Make sure to install the latest version of PowerGUI before using the extension

Current Functions

IntelliSense support through a custom PowerShell editor

Syntax highlighting and script analysis

Supports PowerGUI settings

Supports PowerGUI imported modules

Supports PowerGUI Snippets

0bcea5a3-42a2-495f-ad88-d1a239d96539|0|.0

Tags:

Free Icons for Development

by mark shiffer 22. May 2010 04:32

Ran across an article here: 13,000+ Free Icons for Web and Desktop Developmentwith some links to free icon sets. They may come in handy at some point. The article shows the icon listings, but here are just the links:

ASP.NET Icons
390 icons, 16x16, GIF
http://www.freeiconsdownload.com/Free_Downloads.asp?id=63

Acxialis – Web Mini, Part 1
267 icons, 16x16, PNG, GIF or ICO
http://www.axialis.com/free/icons/

Diagona
400 icons, 16x16 and 10x10, PNG
http://p.yusukekamiyamane.com/

FamFamFam – Silk Icons
1000 icons, 16x16, PNG
http://www.famfamfam.com/lab/icons/silk/

FatCow - Farm Fresh Web Icons
1400 icons, 16x16 and 32x32, PNG
http://www.fatcow.com/free-icons/

Fugue Icons
6000+ icons, 16x16, PNG
http://p.yusukekamiyamane.com/

Gallery 2 Icons
77 icons, 20x16, GIF
http://paularmstrongdesigns.com/projects/gallery-2-icons/

LED Icons Set
500+ icons, 16x16, PNG
http://led24.de/

Mini Pixel Icons
320 icons, 14x14, GIF
http://icondock.com/free/mini-pixel-icons

SplashyIcons
483 icons, 16x16, PNG
http://splashyfish.com/icons/

Tango Icon Library
645 icons, 16x16, 22x22, 32x32, PNG
http://tango.freedesktop.org/Tango_Icon_Library

TwoTiny + Expansion Pack
121 icons, 16x16, GIF
http://code.google.com/p/twotiny/

Vaga
60 icons, 16x16, PNG
http://www.tenbytwenty.com/products/icon-sets/vaga

Free Web Design Icons Set
310 icons, 16x16, PNG
http://semlabs.co.uk/journal/free-web-design-icon-set

Xiao Icon
72 icons, 16x16, PNG
http://www.ineversay.com/my-works/xiao-icon.html

8fbd77ec-6913-4a17-9a2d-20055dfbe547|0|.0

Tags:

Making Your PC More Environmentally Friendly

by mark shiffer 30. April 2010 21:30

Repeated from a recent posting on Channel 10 For a Greener PC: Granola for Windows

Granola is a new software application that helps you reduce the energy waste that coming from using a computer and leaving it on all the time. The program, smaller than a single MP3, is a “set it and forget it” type of application that automatically optimizes system settings without compromising performance or availability. Granola typically lowers the total system energy use by 10-35% even when a system is 100% utilized, the website claims. It also tracks the energy saved in order to estimate cost savings and carbon emission reductions.

Granola uses a technology called dynamic voltage and frequency scaling or DVFS which is analogous to a “dimmer switch” on a light, says the company. When you don’t need the brightest light, you can dim it via a switch. DVFS works in a similar way – when it needs CPU at full speed, it allows that, but when the PC is in a lower state of activity (like reading a website instead of playing a game), it uses less energy.

You can download Granola for free from here.

9222905e-8f41-4b11-a8a6-e19d19657c3a|0|.0

Tags:

MS Software Consulting Blog

Technical findings during my research and daily going abouts...

Extending Visual Studio Context Menus

Fun Coding Challenges

Development Resources for Any Language!

Examining Entity Framework’s SQL Generation

Nifty Microsoft Internet Explorer Advertising

Unit of Work Pattern for Entity Framework 4 and Unity

Repository Pattern with Entity Framework 4

IntelliSense for PowerShell

Free Icons for Development

Making Your PC More Environmentally Friendly

About the author

Month List

Technical findings during my research and daily going abouts...

About the author

Tag cloud

Month List