Exports X-code

• dapp $9.99 iPhone only
• Interface HD $9.99

Stencils/Sketching only

• AppLayout HD $3.99
• iMockups
• Omnigraffle
• Sketchy
• AppDesigner HD $0.99

In his own words:

When the file has a problem it starts to prune out nodes in the XAML one XML node at a time (I mean it puts back nodes that didn’t solve the problem and tries the next in sequence). It does this starting with the nodes that have no children, then the ones with 1, 2 and so on, until it has to remove the entire body – hopefully the error is found long before this. Using this technique the algorithm tries to give you the most tightly isolated area of the Xaml to focus on.

When it identifies a node, it checks whether removing any attribute helps and returns this in addition to the offending XAML if it resolves the issue.

Link: XAML element is already the child of another element error over at his post.

• Airplay SDK
• DragonFire SDK – provides a BuildCenter
• WinChain (free)

Other interesting ones

• Appcelerator Titanium WebKit wrapper (requires Mac?)
• PhoneGap
• Unity 3D

https://www.google.com/accounts/UnlockCaptcha

or Google Apps for Domain

https://www.google.com/a/[yourdomain]/accounts/UnlockCaptcha

e.g.

https://www.google.com/a/projectliftoff.com/UnlockCaptca

Recipe

        Caliburn.Micro.ConventionManager.AddElementConvention(Of DatePicker)(DatePicker.SelectedDateProperty, "SelectedDate", "SelectedDateChanged")
        Caliburn.Micro.ViewModelBinder.Bind(_reportFilterVm, Me.ReportFilter, Nothing)

Here’s a workaround, without using stored procs. Just IFormatter magic.

You will be able to to this:

Dim ids(0 to 3) as integer
ids(0) = 32
ids(1) = 34
ids(2) = 42
ids(3) = 48
statement = SqlFormatter.Format("SELECT * FROM Persons WHERE PersonId in {0:f0}", ids)

Public Class SqlFormatter
    Implements IFormatProvider, ICustomFormatter

    Public Shared Function Format(ByVal formatString, ByVal ParamArray args()) As String
        Return String.Format(New SqlFormatter(), formatString, args)
    End Function

    Public Function GetFormat(ByVal formatType As System.Type) As Object Implements System.IFormatProvider.GetFormat
        If formatType Is GetType(ICustomFormatter) Then
            Return Me
        Else
            Return Nothing
        End If
    End Function

    Public Function Format(ByVal fmt As String, ByVal arg As Object, ByVal formatProvider As System.IFormatProvider) As String Implements System.ICustomFormatter.Format
        Dim thisFmt As String = String.Empty
        If Not String.IsNullOrEmpty(fmt) Then
            thisFmt = CStr(If(fmt.Length > 1, fmt.Substring(0, 1), fmt))
        End If

        If Not TypeOf (arg) Is String AndAlso TypeOf (arg) Is IEnumerable Then
            Dim sb As New List(Of String)
            If fmt.ToUpper.Equals("N") Then fmt = "f"
            For Each obj In arg
                If obj Is Nothing Then
                    sb.Add("Null")
                Else
                    sb.Add(String.Format(Me, "{0:" + fmt + "}", obj))
                End If
            Next
            Return "(" + String.Join(", ", sb) + ")"
        Else
            Dim formatted As String
            Select Case thisFmt.ToUpper()
                Case "C"
                    ' Escape strings
                    formatted = "'" + CType(arg, String).Replace("'", "''") + "'"
                Case "D"
                    ' Date
                    formatted = "'" + String.Format("{0:Y}-{0:M}-{0:D}", arg) + "'"
                Case Else
                    formatted = HandleOtherFormats(fmt, arg)
            End Select
            Return formatted
        End If

    End Function

    Private Function HandleOtherFormats(ByVal fmt As String, ByVal arg As Object) As String
        If TypeOf arg Is IFormattable Then
            Return DirectCast(arg, IFormattable).ToString(fmt, CultureInfo.CurrentCulture)
        ElseIf arg IsNot Nothing Then
            Return arg.ToString()
        Else
            Return String.Empty
        End If
    End Function
End Class

To the professional developers that read this blog (most of you I’m guessing), prepare to move your hatred and loathing from MS Access to LightSwitch.

I believe this view misrepresents what Lightswitch is.

Lightswitch is a declarative framework to perform databinding straight-through from presentation layer to storage layer, with proper extension points to support validation at the business object layer. It is a distillation of existing framework practices. For instance, based on a Lightswitch spec, there is no reason why one couldn’t build it on top of NHibernate.

In fact, Lightswitch is so declarative that the same spec be deployed against an Azure database, as well as one on SQL Server. It is sufficiently declarative that it can run on the desktop browser as well as fit in the form factor of a smartphone. This is a million miles away from dragging and dropping components, and wiring up event handlers.

This is why I, personally am excited about Lightswitch.

Lightswitch is not a library. It is an application framework for data-oriented applications.

A fix for MSN Messenger crashing on start-up is here:

Start > Run > type “regedit” and hit ok.
In the registry editor, navigate to:
HKEY_CURRENT_USERSoftwareMicrosoftMSNMessengerPerPassportSettings

Under “PerPassportSettings”, you may have multiple entries with numbers representing each Live account you’ve logged in with. In each (or if you only have one), expand the numbered key and look for the string “UTL”. delete the value within “UTL”.

After the UTL value has been cleared from each Passport, your Windows Live Messenger should open without crashing.

The UTL value contains various bits of XML data related to your Live account. It would seem in the past week especially, there’s been a small server glitch resulting in “bad data” being stored in UTL. This “bad data” causes Messenger to crash on startup. The data in UTL will be restored with correct data on your next login.

Sometimes, MSDN gives buggy information. If you are using Composition, there are a number of calisthenics required to make this thing work.

namespace WcfComposition.Web
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.ComponentModel.DataAnnotations;
    using System.Data;
    using System.Linq;
    using System.ServiceModel.DomainServices.EntityFramework;
    using System.ServiceModel.DomainServices.Hosting;
    using System.ServiceModel.DomainServices.Server;
    using System.Data.Objects.DataClasses;
    using System.Data.Objects;
    using System.Linq.Expressions;
    using System.Reflection;
    using System.ServiceModel.DomainServices;

    // Implements application logic using the CompositionEntities context.
    // TODO: Add your application logic to these methods or in additional methods.
    // TODO: Wire up authentication (Windows/ASP.NET Forms) and uncomment the following to disable anonymous access
    // Also consider adding roles to restrict access as appropriate.
    // [RequiresAuthentication]
    [EnableClientAccess()]
    public class OrdersService : LinqToEntitiesDomainService<CompositionEntities>
    {

        public IQueryable<CustomerOrder> GetCustomerOrders()
        {
            return this.ObjectContext.CustomerOrders.Include("OrderDetails");
        }

        public void InsertCustomerOrder(CustomerOrder customerOrder)
        {
            if ((customerOrder.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(customerOrder, EntityState.Added);
            }
            else
            {
                this.ObjectContext.CustomerOrders.AddObject(customerOrder);
            }

            UpdateAssociatedDetails(customerOrder);
        }

        private void UpdateAssociatedDetails(CustomerOrder customerOrder)
        {
            System.Collections.IEnumerable details =
                this.ChangeSet.GetAssociatedChanges<CustomerOrder, EntityCollection<OrderDetail>>
                    (customerOrder, o => o.OrderDetails);
            foreach (OrderDetail detail in details)
            {
                ChangeOperation op = this.ChangeSet.GetChangeOperation(detail);
                switch (op)
                {
                    case ChangeOperation.Insert:
                        if (detail.EntityState != EntityState.Added)
                        {
                            if (detail.EntityState != EntityState.Detached)
                            {
                                this.ObjectContext.ObjectStateManager.ChangeObjectState(detail, EntityState.Added);
                            }
                            else
                            {
                                this.ObjectContext.OrderDetails.AddObject(detail);
                            }
                        }
                        break;

                    case ChangeOperation.Update:
                        if (detail.EntityState == EntityState.Detached)
                        {
                            this.ObjectContext.Attach(detail);
                        }
                        this.ObjectContext.ObjectStateManager.ChangeObjectState(detail, EntityState.Modified);
                        break;

                    case ChangeOperation.Delete:
                        if (detail.EntityState == EntityState.Detached)
                        {
                            this.ObjectContext.OrderDetails.Attach(detail);
                        }
                        customerOrder.OrderDetails.Remove(detail);
                        this.ObjectContext.DeleteObject(detail);
                        break;

                    case ChangeOperation.None:

                        // MSDN had omitted these
                        if (detail.EntityState == EntityState.Added)
                            this.ObjectContext.ObjectStateManager.ChangeObjectState(detail, EntityState.Unchanged);
                        break;

                    default:
                        break;
                }

            }

            double totalPrice = customerOrder.OrderDetails.Sum(d => d.Price);
            customerOrder.TotalPrice = (float) totalPrice;
        }

        public void UpdateCustomerOrder(CustomerOrder currentCustomerOrder)
        {
            try
            {
                if (currentCustomerOrder.EntityState == EntityState.Detached)
                {

                    CustomerOrder originalOrder = this.ChangeSet.GetOriginal(currentCustomerOrder);
                    if (originalOrder != null)
                    {
                        this.ObjectContext.CustomerOrders.AttachAsModified(currentCustomerOrder, originalOrder);

                    }
                    else
                    {
                        // http://social.msdn.microsoft.com/Forums/en/adodotnetentityframework/thread/a633a58e-85ad-4e77-be80-b1855bfd2b42
                        this.ObjectContext.CustomerOrders.AddObject(currentCustomerOrder);
                        this.ObjectContext.ObjectStateManager.ChangeObjectState(currentCustomerOrder, EntityState.Unchanged);

                        // MSDN is wrong.
                        // this.ObjectContext.CustomerOrders.Attach(currentCustomerOrder);
                    }
                }

                UpdateAssociatedDetails(currentCustomerOrder);
            }
            catch (Exception exc)
            {
                string message = exc.Message;
                throw;
            }

        }

        public void DeleteCustomerOrder(CustomerOrder customerOrder)
        {
            if ((customerOrder.EntityState == EntityState.Detached))
            {
                this.ObjectContext.CustomerOrders.Attach(customerOrder);
            }
            foreach (var detail in customerOrder.OrderDetails.ToList())
                this.ObjectContext.DeleteObject(detail);
            this.ObjectContext.CustomerOrders.DeleteObject(customerOrder);
        }

    }

}

Formatting courtesy of Code to HTML format

There are six possible combinations to consider.

1. entire date range falls outside of our specified range (too early)
2. date partially falls partially inside our range (start date out of range)
3. date range encompasses our range entirely
4. date falls entirely inside our range
5. date partially falls inside our range (end date out of range)
6. date falls outside our specified range (too late)

The hard way to do this is to handle cases 2, 3, 4 and 5 using an OR criteria, since each criteria requires two checks, this results in total of 8 tests.

The easy way is to handle cases 1 and 6, which only requires a single test for each.

   Not (EndDate < '2010-01-15:00:00:00' Or StartDate > '2010-03-15:00:00:00')

which can be simplified to

   EndDate => '2010-01-15:00:00:00' And StartDate =< '2010-03-15:00:00:00'