If you live in the US, please take a look at this petition to allow H4 visa holders (spouses etc who are wholly dependent on other visa holders, like H1’s – which companies like Microsoft benefit from) to seek employment:

http://wh.gov/gDr

It’s on the new “We the People” page on the White House site…  Pretty cool, although interesting to see legalizing marijuana and acknowledging an “extra terrestrial presence engaging the human race” are considered such major priorities

Thanks!

—

Other similar petitions:

• Allow Seriously Backlogged EB2/EB3 Beneficiaries with Their I-140 Approved to File I-485 and Apply for EAD & AP (although suggests it’s only an issue for certain countries of origin; in reality it’s anyone who’s on EB3, but certainly worse for “oversubscribed” countries).
• Legal Employment-based Immigration Petitioners Help U.S. Companies and Should NOT be Heavily Backlogged for Years
• Allow H-4 Visa member to work legally

Go get it here! (or at http://awesomium.com).

LINQ To SQL doesn’t provide a way to include Xquery expressions in queries.  The simplest solution is to create SQL user-defined functions that perform the Xquery for you and return scalar results.

This works pretty well for small databases, but you lose the benefit of SQL Server’s XML indexes.  To get around that, we can modify the SQL command text to expand the function calls into raw Xquery expressions.

There are a couple of ways to do this, depending on the complexity / flexibility required for your query.  For simple queries you can use the DataContext.GetCommand method, modify the command, and get the results through DataContext.Translate or DataContext.ExecuteQuery.  For complex queries (particularly ones that need to shape the results) you’ll need to jump through a couple of Reflection hoops.

Since we don’t actually need to call the SQL user-defined functions, we can just create empty placeholders.  Here’s a sample table and functions:

-- =============================================
-- Author:      Chris Cavanagh
-- Create date: 3/15/2011
-- Description: Demo table
-- =============================================
CREATE TABLE [dbo].[MyXmlFieldTable](
    [UID] [uniqueidentifier] NOT NULL,
    [TimeCreated] [datetime] NOT NULL,
    [XmlValues] [xml] NULL,
 CONSTRAINT [PK_MyXmlFieldTable] PRIMARY KEY
(
    [UID] ASC
) WITH (PAD_INDEX  = OFF, STATISTICS_NORECOMPUTE  = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS  = ON, ALLOW_PAGE_LOCKS  = ON) ON [PRIMARY]
) ON [PRIMARY]

GO

ALTER TABLE [dbo].[MyXmlFieldTable] ADD  CONSTRAINT [DF_MyXmlFieldTable_TimeCreated]  DEFAULT (getdate()) FOR [TimeCreated]
GO

-- =============================================
-- Author:      Chris Cavanagh
-- Create date: 3/15/2011
-- Description: Get XQuery value (string)
-- =============================================
CREATE FUNCTION XQueryString
(
    @xml xml,
    @xpath varchar(200)
)
RETURNS nvarchar(4000)
AS
BEGIN
    DECLARE @Result nvarchar(4000)
    RETURN @Result
END
GO

-- =============================================
-- Author:      Chris Cavanagh
-- Create date: 3/15/2011
-- Description: Get XQuery value (datetime)
-- =============================================
CREATE FUNCTION XQueryDateTime
(
    @xml xml,
    @xpath varchar(200)
)
RETURNS datetime
AS
BEGIN
    DECLARE @Result datetime
    RETURN @Result
END
GO

-- =============================================
-- Author:      Chris Cavanagh
-- Create date: 3/15/2011
-- Description: Get XQuery value (float)
-- =============================================
CREATE FUNCTION XQueryFloat
(
    @xml xml,
    @xpath varchar(200)
)
RETURNS float
AS
BEGIN
    DECLARE @Result float
    RETURN @Result
END
GO

-- =============================================
-- Author:      Chris Cavanagh
-- Create date: 3/15/2011
-- Description: Get XQuery value (bit)
-- =============================================
CREATE FUNCTION XQueryBit
(
    @xml xml,
    @xpath varchar(200)
)
RETURNS bit
AS
BEGIN
    DECLARE @Result bit
    RETURN @Result
END
GO

-- =============================================
-- Author:      Chris Cavanagh
-- Create date: 3/15/2011
-- Description: Get XQuery value (compare)
-- =============================================
CREATE FUNCTION XQueryCompare
(
    @xml xml,
    @xpath varchar(200),
    @oper varchar(10),
    @value nvarchar(4000)
)
RETURNS bit
AS
BEGIN
    DECLARE @Result bit
    RETURN @Result
END
GO

Once you add these functions to your DBML file (through the designer, or manually if you prefer) you’ll be able to write LINQ queries that call them.  Here’s a simple example:

var results = from r in MyXmlFieldTable
    let date = context.XQueryDateTime( r.XmlValues, "MyContainer/MyDateTime" )
    where date < DateTime.Now.AddDays( -5 )
    select new
    {
        Date = date,
        FirstName = context.XQueryString( r.XmlValues, "MyContainer/FirstName" ),
        LastName = context.XQueryString( r.XmlValues, "MyContainer/LastName" )
    };

With this, we can use some Regex magic to expand the function names into XQuery expressions:

public class XQueryHelper
{
    private static Regex regex = new Regex( @"\[dbo\]\.\[XQuery(?<type>.*?)\]\(\s?(?<column>\([^\(\)]*(((?'Open'\()[^\(\)]*)+((?'Close-Open'\))[^\(\)]*)+)*(?(Open)(?!))\)|([\s\S]*?)),\s?(?<xpath>.*?)(,\s?(?<oper>.*?),\s?(?<value>.*?))?\s?\)", RegexOptions.Compiled );

    public static string OptimizeSql( string commandText, IDictionary<string, object> parameters )
    {
        return regex.Replace(
            commandText,
            delegate( Match m )
            {
                var column = m.Groups[ "column" ].Value;
                var xpath = parameters[ m.Groups[ "xpath" ].Value ];

                var sqlType = "nvarchar( 4000 )";
                var compare = "";
                var type = m.Groups[ "type" ].Value;

                switch ( type )
                {
                    case "Float": sqlType = "float"; break;
                    case "DateTime": sqlType = "datetime"; break;
                    case "Bit": sqlType = "int"; compare = " = 1"; break;
                    case "Compare":
                    {
                        var oper = parameters[ m.Groups[ "oper" ].Value ];
                        var valueParam = m.Groups[ "value" ].Value;

                        var value = valueParam.StartsWith( "@" )
                            ? string.Format( "sql:variable(\"{0}\")", valueParam )
                            : string.Format( "\"{0}\"", valueParam );

                        return string.Format( "{0}.exist('{1}[.{2}{3}]')", column, xpath, oper, value );
                    }
                }

                return string.Format( "{0}.value('({1})[1]', '{2}'){3}", column, xpath, sqlType, compare );
            } );
    }
}

Here’s where you need to decide between the “safe” and risky ways to manipulate the command text.  Here’s the safe way:

    var command = context.GetCommand( results );
    var parameters = command.Parameters.Cast<DbParameter>().ToDictionary( p => p.ParameterName, p => p.Value );

    command.CommandText = XQueryHelper.OptimizeSql( command.CommandText, parameters );

    var newResults = context.ExecuteQuery( command.CommandText, parameters.Values );

The riskier (but more flexible and robust) way is discussed here.  Using this, all you need to do is modify your DataContext before executing the query.

    context = DataContextInterceptor.Intercept( context, XQueryHelper.OptimizeSql );

Hope you find this useful!

HACK WARNING – This example calls private framework methods through Reflection.  It’s bad practice in almost every way.  Also, it’s unlikely to work in a partial trust environment.  Use at your own risk

Here’s a bit of code that’ll let you modify any command text LINQ To SQL generates before it hits the database.  It’s always been possible to call DataContext.GetCommand and use modified SQL in a call to DataContext.Translate or DataContext.ExecuteQuery, but that’s pretty restrictive in the complexity of query you can use.  Also, if LINQ To SQL decides it needs to batch multiple SELECT statements for the desired results, GetCommand can only give you the first one.

The first thing to do is replace the IProvider implementation used by your DataContext.  Unfortunately, DataContext’s Provider property is both private and read-only.  Also, the IProvider interface itself is private.  This is bad in every way, and we absolutely shouldn’t try to hack our way through that… but we will.

Inspired by a 2008 post by Matt Warren, I made the following DataContextInterceptor helper.  It intercepts calls to the IProvider’s Compile and Execute methods.  Rather than rewrite most of the SqlProvider code, it calls the same private methods it normally would, albeit through reflection.  The only other thing it does is call the ModifyCommandDelegate delegate (assigned by your code) with the command text and parameters.

Although it’s not the cleanest solution, it’s pretty much transparent to LINQ To SQL.  You can use complex queries (even compiled ones via CompiledQuery.Compile) and they work just fine:

    public class DataContextInterceptor
    {
        public delegate string ModifyCommandDelegate( string commandText, IDictionary<string, object> parameters );

        private DataContext dc;
        private object oldProvider;
        private Type providerType;
        private ModifyCommandDelegate modifyCommand;

        public static TDataContext Intercept<TDataContext>( TDataContext dc, ModifyCommandDelegate modifyCommand )
            where TDataContext : DataContext
        {
            new DataContextInterceptor( dc, modifyCommand );

            return dc;
        }

        public DataContextInterceptor( DataContext dc, ModifyCommandDelegate modifyCommand )
        {
            this.dc = dc;
            this.modifyCommand = modifyCommand;

            FieldInfo providerField = typeof( DataContext ).GetField( "provider", BindingFlags.Instance | BindingFlags.NonPublic );
            var existingProvider = providerField.GetValue( dc );

            if ( existingProvider is SqlProvider )
            {
                oldProvider = existingProvider;

                var proxy = new ProviderProxy( this, oldProvider ).GetTransparentProxy();

                providerField.SetValue( dc, proxy );
            }
        }

        public static MethodInfo GetMethod( Type type, string methodName, params object[] args )
        {
            var hasNullArgs = args.Any( a => a == null );

            var method = hasNullArgs
                ? type.GetMethods( BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic )
                    .FirstOrDefault( m => m.Name == methodName )
                : null;

            if ( method == null && !hasNullArgs )
            {
                method = type.GetMethod(
                    methodName,
                    BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
                    null,
                    args.Select( a => a.GetType() ).ToArray(),
                    null );
            }

            return method;
        }

        private object Invoke( object instance, string methodName, params object[] args )
        {
            var type = instance.GetType();
            var method = GetMethod( type, methodName, args );

            return ( method != null )
                ? method.Invoke( instance, args )
                : null;
        }

        private object Invoke( Type type, string methodName, params object[] args )
        {
            var method = type.GetMethod( methodName, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic );

            return method.Invoke( null, args );
        }

        protected object CompileImpl( Expression query )
        {
            var assembly = typeof( SqlProvider ).Assembly;

            /*
            this.CheckDispose();
            this.CheckInitialized();
            if ( query == null )
            {
                throw Error.ArgumentNull( "query" );
            }
            */

            // this.InitializeProviderMode();
            Invoke( oldProvider, "InitializeProviderMode" );

            // SqlNodeAnnotations annotations = new SqlNodeAnnotations();
            var annotations = Activator.CreateInstance( assembly.GetType( "System.Data.Linq.SqlClient.SqlNodeAnnotations" ) );

            // QueryInfo[] queries = this.BuildQuery( query, annotations );
            var queries = Invoke( oldProvider, "BuildQuery", query, annotations );

            var info = ModifyQueries( (IEnumerable)queries );

            // this.CheckSqlCompatibility( queries, annotations );
            Invoke( oldProvider, "CheckSqlCompatibility", queries, annotations );

            LambdaExpression expression = query as LambdaExpression;

            if ( expression != null )
            {
                query = expression.Body;
            }

            // IObjectReaderFactory readerFactory = null;
            object readerFactory = null;

            // ICompiledSubQuery[] subQueries = null;
            object subQueries = null;

            // QueryInfo info = queries[ queries.Length - 1 ];
            // info defined above

            var resultShape = (int)Invoke( info, "get_ResultShape" );

            // if ( info.ResultShape == ResultShape.Singleton )
            if ( resultShape == 1 /* Singleton */ )
            {
                // subQueries = this.CompileSubQueries( info.Query );
                subQueries = Invoke( oldProvider, "CompileSubQueries", Invoke( info, "get_Query" ) );

                // readerFactory = this.GetReaderFactory( info.Query, info.ResultType );
                readerFactory = Invoke( oldProvider, "GetReaderFactory", Invoke( info, "get_Query" ), Invoke( info, "get_ResultType" ) );
            }
            // else if ( info.ResultShape == ResultShape.Sequence )
            else if ( resultShape == 2 /* Sequence */ )
            {
                // subQueries = this.CompileSubQueries( info.Query );
                subQueries = Invoke( oldProvider, "CompileSubQueries", Invoke( info, "get_Query" ) );

                // readerFactory = this.GetReaderFactory( info.Query, TypeSystem.GetElementType( info.ResultType ) );
                var resultType = Invoke( info, "get_ResultType" );
                var typeSystemType = assembly.GetType( "System.Data.Linq.SqlClient.TypeSystem" );
                var elementType = Invoke( typeSystemType, "GetElementType", resultType );

                readerFactory = Invoke( oldProvider, "GetReaderFactory", Invoke( info, "get_Query" ), elementType );
            }

            FieldInfo providerField = typeof( DataContext ).GetField( "provider", BindingFlags.Instance | BindingFlags.NonPublic );
            providerField.SetValue( dc, oldProvider );

            // return new CompiledQuery( this, query, queries, readerFactory, subQueries );
            var compiledQueryType = assembly.GetType( "System.Data.Linq.SqlClient.SqlProvider+CompiledQuery" );

            return Activator.CreateInstance(
                compiledQueryType,
                BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
                null,
                new object[] { oldProvider, query, queries, readerFactory, subQueries },
                null );
        }

        protected internal virtual IExecuteResult ExecuteImpl( Expression query )
        {
            var assembly = typeof( SqlProvider ).Assembly;

            /*
            this.CheckDispose();
            this.CheckInitialized();
            this.CheckNotDeleted();
            if (query == null)
            {
                throw Error.ArgumentNull("query");
            }
            */

            // this.InitializeProviderMode();
            Invoke( oldProvider, "InitializeProviderMode" );

            // query = Funcletizer.Funcletize(query);
            var funcletizerType = assembly.GetType( "System.Data.Linq.SqlClient.Funcletizer" );
            query = (Expression)Invoke( funcletizerType, "Funcletize", query );

            // if ( this.EnableCacheLookup )
            if ( (bool)Invoke( oldProvider, "get_EnableCacheLookup" ) )
            {
                // IExecuteResult cachedResult = this.GetCachedResult(query);
                object cachedResult = Invoke( oldProvider, "GetCachedResult", query );

                if ( cachedResult != null )
                {
                    // return cachedResult;
                    return (IExecuteResult)cachedResult;
                }
            }

            // SqlNodeAnnotations annotations = new SqlNodeAnnotations();
            var annotations = Activator.CreateInstance( assembly.GetType( "System.Data.Linq.SqlClient.SqlNodeAnnotations" ) );

            // QueryInfo[] queries = this.BuildQuery(query, annotations);
            var queries = Invoke( oldProvider, "BuildQuery", query, annotations );

            var info = ModifyQueries( (IEnumerable)queries );

            // this.CheckSqlCompatibility(queries, annotations);
            Invoke( oldProvider, "CheckSqlCompatibility", queries, annotations );

            LambdaExpression expression = query as LambdaExpression;

            if ( expression != null )
            {
                query = expression.Body;
            }

            // IObjectReaderFactory readerFactory = null;
            object readerFactory = null;

            // ICompiledSubQuery[] subQueries = null;
            object subQueries = null;

            // QueryInfo info = queries[queries.Length - 1];
            // info defined above

            var resultShape = (int)Invoke( info, "get_ResultShape" );

            // if (info.ResultShape == ResultShape.Singleton)
            if ( resultShape == 1 /* Singleton */ )
            {
                // subQueries = this.CompileSubQueries(info.Query);
                subQueries = Invoke( oldProvider, "CompileSubQueries", Invoke( info, "get_Query" ) );

                // readerFactory = this.GetReaderFactory(info.Query, info.ResultType);
                readerFactory = Invoke( oldProvider, "GetReaderFactory", Invoke( info, "get_Query" ), Invoke( info, "get_ResultType" ) );
            }
            // else if (info.ResultShape == ResultShape.Sequence)
            else if ( resultShape == 2 /* Sequence */ )
            {
                // subQueries = this.CompileSubQueries(info.Query);
                subQueries = Invoke( oldProvider, "CompileSubQueries", Invoke( info, "get_Query" ) );

                // readerFactory = this.GetReaderFactory(info.Query, TypeSystem.GetElementType(info.ResultType));
                var resultType = Invoke( info, "get_ResultType" );
                var typeSystemType = assembly.GetType( "System.Data.Linq.SqlClient.TypeSystem" );
                var elementType = Invoke( typeSystemType, "GetElementType", resultType );

                readerFactory = Invoke( oldProvider, "GetReaderFactory", Invoke( info, "get_Query" ), elementType );
            }

            // return this.ExecuteAll(query, queries, readerFactory, null, subQueries);
            return (IExecuteResult)Invoke( oldProvider, "ExecuteAll", query, queries, readerFactory, null, subQueries );
        }

        private object ModifyQueries( IEnumerable queries )
        {
            object lastQuery = null;

            foreach ( var q in queries )
            {
                lastQuery = q;

                var commandTextField = q.GetType().GetField( "commandText", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic );
                var parametersField = q.GetType().GetField( "parameters", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic );

                var commandText = (string)commandTextField.GetValue( q );
                var parameters = new Dictionary<string, object>();

                foreach ( var p in (IEnumerable)parametersField.GetValue( q ) )
                {
                    var name = (string)Invoke( Invoke( p, "get_Parameter" ), "get_Name" );
                    parameters[ name ] = Invoke( p, "get_Value" );
                }

                var modifiedCommandText = modifyCommand( commandText, parameters );

                commandTextField.SetValue( q, modifiedCommandText );
            }

            return lastQuery;
        }

        public class ProviderProxy : RealProxy, IRemotingTypeInfo
        {
            DataContextInterceptor extender;
            object oldProvider;

            internal ProviderProxy( DataContextInterceptor extender, object oldProvider )
                : base( typeof( ContextBoundObject ) )
            {
                this.extender = extender;
                this.oldProvider = oldProvider;
            }

            public override IMessage Invoke( IMessage msg )
            {
                if ( msg is IMethodCallMessage )
                {
                    IMethodCallMessage call = (IMethodCallMessage)msg;
                    MethodInfo mi = null;

                    if ( call.MethodBase.DeclaringType.Name == "IProvider" && call.MethodBase.DeclaringType.IsInterface )
                    {
                        extender.providerType = call.MethodBase.DeclaringType;

                        mi = DataContextInterceptor.GetMethod( typeof( DataContextInterceptor ), call.MethodBase.Name + "Impl", call.Args );

                        if ( mi == null && oldProvider != null )
                        {
                            mi = DataContextInterceptor.GetMethod( call.MethodBase.DeclaringType, call.MethodBase.Name, call.Args );

                            return new ReturnMessage( mi.Invoke( oldProvider, call.Args ), null, 0, null, call );
                        }

                        if ( mi != null )
                        {
                            try
                            {
                                return new ReturnMessage( mi.Invoke( this.extender, call.Args ), null, 0, null, call );
                            }
                            catch ( TargetInvocationException e )
                            {
                                return new ReturnMessage( e.InnerException, call );
                            }
                        }
                    }
//                    else mi = typeof( DataContextInterceptor ).GetMethod( call.MethodBase.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic );
                    else
                    {
                        mi = DataContextInterceptor.GetMethod( oldProvider.GetType(), call.MethodBase.Name, call.Args );

                        if ( mi != null )
                        {
                            try
                            {
                                return new ReturnMessage( mi.Invoke( oldProvider, call.Args ), null, 0, null, call );
                            }
                            catch ( TargetInvocationException e )
                            {
                                return new ReturnMessage( e.InnerException, call );
                            }
                        }
                    }

                    throw new NotImplementedException(
                        string.Format( "Method not found: {0}( {1} )",
                            call.MethodBase.Name,
                            string.Join( ", ", call.Args.Select( a => Convert.ToString( a ) ) ) ) );
                }

                throw new NotImplementedException();
            }

            public bool CanCastTo( Type fromType, object o )
            {
                return true;
            }

            public string TypeName
            {
                get { return this.GetType().Name; }
                set { }
            }
        }
    }

Hope this helps!

Here’s a small MVC extension method that looks useful, but might be totally redundant:

public static void RenderPartial<TModel, TProperty>( this HtmlHelper<TModel> helper, string partialViewName, Expression<Func<TModel, TProperty>> expression )
{
    var model = (TModel)helper.ViewData.Model;
    var childModel = expression.Compile()( model );
    var viewData = new ViewDataDictionary<TProperty>( childModel );
    viewData.TemplateInfo.HtmlFieldPrefix = ExpressionHelper.GetExpressionText( expression );

    helper.RenderPartial( partialViewName, childModel, viewData );
}

Basically it’s the same as the regular Html.RenderPartial but you can pass your model as an expression.  It’ll handle getting the field name prefixes etc. automatically.

I’m pretty sure the same thing can be achieved with Html.EditorFor and Html.DisplayFor (possibly with better performance too, depending on if they take the Compile() hit or not).  However I could be wrong, so I posted it anyway

Other than that, $99/year for 4 Gold accounts is a nice deal

Update 1: Canceling the pack isn’t a sure fix (they’re looking into it ).
Update 2: Others with same issue - http://forums.xbox.com/34945194/ShowPost.aspx#34945194

I’ve updated my WPF Chromium WebBrowser for .NET 4.0 and Awesomium 1.6 RC1.  You can find the source code here on CodePlex.

Cjc.ChromiumBrowserDemo adds a couple of new features:

• Zoom in / out buttons.
• “Console” checkbox – Shows a console allowing you to execute arbitrary javascript on the page.

It currently has a few known issues:

• Resizing the page (either directly or while rotating) can cause some flicker.  This should be improved by an upcoming Awesomium tweak.
• Some javascript can cause the console to “die” and ignore subsequent statements.  Don’t use “document” or “window” on their own.  However it appears safe to use things like this:

  document.getElementById( ‘myElement’ ).style.background = ‘red’

To build the solution, make sure you also download Awesomium 1.6 RC1 (direct link) and place it in an Awesomium folder below the root.  Your folders should look something like this:

Cjc.WpfChromium.4.0
– Awesomium
—- build
—- docs
—- include
—- samples
– Cjc.AwesomiumWrapper
– Cjc.ChromiumBrowser
– Cjc.ChromiumBrowserDemo
– Cjc.WebSnapshot (optional)

I’ll aim to post a new ClickOnce demo in the next few days.

• Like the print functionality, it’ll only let you save images that are checked.  If you use the File –> Save as option, it’ll save the currently selected and checked file.  If you use the Save and Export –> Save option, it’ll save all checked images.
• Files aren’t saved with the name you tell it to use   Since it can save a batch of files, it gives each one a name based on the name you specify combined with the original name.  So if your original is called Original.jpg and you save the edited image as MyNew.jpg, the result will be MyNew_Original.jpg.  Totally weird but I didn’t want to give it too much thought just yet.
• It scales saved images to fit an [arbitrarily sized] 3000 x 3000 box, retaining the required aspect ratio.  This could be improved (so it could figure out an appropriate size based on the original size and transforms you applied), but I decided to leave that as a later exercise.
• It requires .NET 4.0 or above (if using ClickOnce link, it might install that for you if needed).

The ClickOnce app is available here, and the source is on CodePlex as usual.

I’ve finally put source code for my Windows Phone 7 Soft-Body Physics demo on CodePlex!  As a bonus it runs much faster with the current emulator.  You can get it here