ondrejsv

Getting rid of The current page has been customized warning in SharePoint 2010

Mon, 26 Dec 2011 18:18:51 +0200

New WikiEditPage’s in SharePoint 2010 are great. Users finally may place web parts anywhere on the page and they don’t need any cumbersome ContentEditorWebPart’s with odd “Edit RTF” buttons.

There are times, however, when developers (or even power users from SPD) customize the page, to include some javascripts or other goodies. After customization of a WikiEditPage SharePoint shows a yellow warning (more precisely called status) in the display mode:

Not pretty. How to get rid of it? SharePoint supports an undocumented file property called “HidePageUnghostMessageV4”. Based on its name I suppose its sole purpose is to hide the message when the page is unghosted (i.e. customized). There seems to be a bug in the rendering code because when I set the property to “true”:

only the hyperlink for reverting disappears:

It’s possible that it’s not a bug but a feature but I would more appreciate if the flag worked by completely disabling the warning and not only the hyperlink.

The only way I know to turn off the warning now is to write a custom derived subclass of the SharePoint’s WikiEditPage that does not render the JavaScript for rendering the status warning (these messages are inserted in the status bar by calling the SP.UI.Status.addStatus JS function). WikiEditPage emits a little JavaScript code in the PreRender method by calling the well-known ScriptManager.RegisterStartupClientScriptBlock. Note that there is no way to unregister such a startup script. I mitigated this little complication by registering a startup script with the same key as WikiEditPage uses and with no body first, before the original PreRender code gets chance:


namespace Ondrejsv.CustomWikiEditPage
{
    public class CustomWikiEditPage : WikiEditPage
    {
        protected override void OnPreRender(EventArgs e)
        {
            ScriptManager.RegisterStartupScript((Page)this, typeof(WikiEditPage), "unghostWarning", "", true);

            base.OnPreRender(e);
        }
    }
}

The ordering of the statements is crucial here because if the base method call was first then the ScriptManager would emit the original script.

Don’t forget to place an entry into the SafeControl list, too. I created a Visual Studio solution for all of this and you may download it and deploy to your farm.

Now open your page in the SharePoint Designer and change the Inherits attribute in the Page directive from Microsoft.SharePoint.WebPartPages.WikiEditPage to Ondrejsv.CustomWikiEditPage.CustomWikIEditPage (or whatever you call your custom class) and add a new Assembly directive for SharePoint to find the class (you may omit this directive if you place the full name in the Inherits attribute, of course):

No more the yellow pesky warning:

Note that any other warnings get displayed correctly:

Download the VS solution.

On efficiency loss with JavaScript

Thu, 15 Sep 2011 22:34:23 +0200

With the hype of Windows 8 HTML5/JS apps I’m again and again rediscovering some of the pitfalls of the JavaScript language which bring issues we never have with strongly-typed languages like C#.

The first scenario is going to be quite common not only when using the new promise/then feature. (Snippet is taken from one the tutorials on the MSDN.) Look at the processPosts function that gets called when the xhr promise gets asynchronously fulfilled. There is no way the IDE would know the type (more precisely available methods and fields) of the argument and thus providing IntelliSense because the function could be called from everywhere:

If we write the code to run when the promise is fulfilled as an anonymous function and Visual Studio would be way smarter, it could theoretically provide IntelliSense on the result argument by parsing and processing the xhr promise but it does not so:

The second pitfall comes from the fact that any code could be run in a context of any HTML file. When you reference a .js file from an HTML page, some of the global variables get alive by getting references of the screen elements with variables of the same id. If you make a typo in the name of a variable, you would not find it out until you run the page. Of course, there is no IntelliSense either because the variable could be of any dynamic type at run-time. This pitfall is really a feature of all dynamic languages but for a programmer used to program user interfaces in ASP.NET and Silverlight which have concepts of code-behind coded in strongly-typed C# it represents a loss in efficiency, indeed.

Some observations on managed Windows 8 metro applications

Thu, 15 Sep 2011 20:20:43 +0200

This is an unstructured list of interesting things I found when playing with the new metro applications.

While HTML5/JS metro applications always run in a host process WWAHost.exe (Windows Web Application Host?), .NET apps does not, they run directly in its own process:

When deployed locally from the Visual Studio, applications (both HTML5/JS and .NET) are stored within the folder AppxLayouts in the user folder. It is interesting that XAML and content files are not embedded as resources in the executable but they are left alone:

As the WinRT is native, every external event such as Click comes from the blackbox:

If we look at modules currently loaded when a managed application is running:

we’ll find some interesting things:

despite the fact that in a Metro app you may use only a subset of the full .NET, it looks like some of the full .NET modules are loaded (mscorlib.dll, System.Runtime.dll, System.Linq.dll, System.Core.dll, System.dll, System.Xml.dll and others), so a managed application obviously does not only forward calls to the native WinRT,
of course, a number of WinRT modules are loaded (with .winmd extensions)

.NET 4.5 assembly references are evident if we look at the application from the Reflector:

List of Windows 8 Metro applications in DevPreview

Wed, 14 Sep 2011 23:13:33 +0200

We all know that that there are two main approaches to develop new “Metro” style applications in Windows 8: HTML5/JavaScript and .NET (predominantly C# and VB.NET) and one complementary approach (C++/XAML). What technologies did Microsoft choose to write demo applications coming in the Developer Preview?

Here’s a short list containing all applications packed up in the Windows 8 Developer Preview together with technologies they are build on and other comments.

So what would be a management summary? 29 applications, 5 of which are written in .NET/XAML, 2 probably in C++/XAML and the rest are HTML5/JS.

Name	Technology	Comment	Immersive tile
Alarms	HTML5/JS
Piano (audiotagpiano)	HTML5/JS
BitBox	HTML5/JS	sound loops sequencer
BUILD	HTML5/JS	just a little app showing BUILD sessions
Copper	C++/XAML ???	simple 3D demo
Five in row	HTML5/JS
Flashcards	HTML5/JS
News (hermes)	HTML5/JS
Chess (checkm8)	.NET/XAML
Ink Pad	HTML5/JS
Labyrinth	HTML5/JS
Measure It	HTML5/JS
Memories	.NET/XAML
Mopod	HTML5/JS
Air Craft (myplane)	HTML5/JS
Near Me	HTML5/JS
Notespace	HTML5/JS
PaintPlay	HTML5/JS
Picture Stream (picstream)	.NET/XAML
Socialite	HTML5/JS
Stock	HTML5/JS
Sudoku	.NET/XAML	includes Tim Heuer’s code
Tile Puzzle	HTML5/JS
Treehouse Stampede!	HTML5/JS
Tube Rider	C++/XAML ???
Tweet@rama	HTML5/JS
Weather	HTML5/JS
Word Hunt	HTML5/JS
Zero Gravity	.NET/XAML	Ported Windows Phone 7 application

Visual Studio and Resharper snippet for MSTest method

Wed, 18 May 2011 22:28:21 +0200

Visual Studio comes with an OOTB MSTest method snippet accessible via the testm shortcut. Two thing missing in it for me:

standard naming convention as mentioned also in the The Art of Unit Testing by Roy Oshrove (TestedMethod_StateUnderTest_ExpectedResult),
separation of Arrange, Act and Assert parts of the code by clearly visible comments.

I’ve been observing that VS code snippets are for not widely used some reason. Perhaps the clunky Snippet Manager in Visual Studio or necessity to edit snippets in XML by hand… who knows…

So here’s how looks my new snippet:

Trivial as it is but useful very much.

Download clean VS version or ReSharper snippet (aka Live Template).

Fighting the spam II

Sun, 15 May 2011 19:51:43 +0200

I was running on BlogEngine 1.5 with Askimet antispam protection until today. BlogEngine became notoriously infamous for allowing spammers post fake comments. Just make an image yourself:

More than 8500 comments waiting for approval and 225 automatically approved comments – among these approved comments majority is successful spam that got through antispam filter.

It is above human forces to go through all these thousands of comments so I ‘m going to write a script against BlogEngine API to delete it all – sorry if any of your comment is there.

I upgraded to BlogEngine 2.0 and enabled TypePadFilter together with Askimet. Also I enabled SimpleCaptcha which asks you a simple equation before it allows to post your comment. And I was forced to automatically close posting new comments after 90 days just for sure. Sorry for any inconvenience. If you want to write me about an article posted 90 days ago you may do so by using the contact form directly.

UPDATE: Clearing unapproved comments was not difficult at all – BlogEngine has even a built-in method for that in its web services API -- it’s well hidden in the api/Comments.asmx service and it’s name is DeleteAll (don’t get confused by its name; it deletes only unapproved comments as you can see from source codes).

N2CMS, NHibernate, SqlCommandSet and medium trust

Sun, 15 May 2011 13:14:44 +0200

Recently I installed the current version of the N2CMS to power my personal homepage. I’m running on shared webhosting so you may imagine how poor performance is. To speed up the thing a little I decided to switch from SqlCe database to the full blown SQL Server.

However, after changing the connection string the N2CMS does not even install itself:

Attempt by method 'NHibernate.AdoNet.SqlClientSqlCommandSet..ctor()' to access method 'System.Data.SqlClient.SqlCommandSet..ctor()' failed.

If you carefully look at the source code of the NHibernate.AdoNet.SqlClientSqlCommandSet, you will discover the ugly reflection:


    /// 
    /// Expose the batch functionality in ADO.Net 2.0
    /// Microsoft in its wisdom decided to make my life hard and mark it internal.
    /// Through the use of Reflection and some delegates magic, I opened up the functionality.
    ///     
    /// Observable performance benefits are 50%+ when used, so it is really worth it.
    /// 
    
    public class SqlClientSqlCommandSet 
...


        static SqlClientSqlCommandSet()
        {
            Assembly sysData = Assembly.Load("System.Data, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089");
            sqlCmdSetType = sysData.GetType("System.Data.SqlClient.SqlCommandSet");
            Debug.Assert(sqlCmdSetType != null, "Could not find SqlCommandSet!");
        }

To continue installing, either make the reflection work by switching your application to full trust (provided your hosting company will allow this):

or disable NHibernate batching feature (and you will lose “observable performance benefirst 50%+” as the author of the NHibernate comment claims ) by following the commit message:

Enabling batching is done by defining (the new) property "hibernate.batch_size" to a size greater than zero. This way require an explicit action to enable it, but this is probably a good thing.

Visual Studio 2010 SP1 reapplication fails

Fri, 06 May 2011 18:16:25 +0200

My first attempt to install VS 2010 SP1 failed as the setup hanged (see Visual Studio 2010 Service Pack 1 installing for over 2 hours could be a sign of a problem). The real problem was the rollback also hanged and this is always a sign of big trouble.

After reboot I started SP1 setup again and chose to reapply SP1. In a while I was prompted to find silverlight_sdk.msi because the installer could not have found it. It is located in the Silverligh4/1033 folder on the installation media. The installer seemed to be happy with my choice and continued. Almost at the end of the installation I was prompted again – now for the vc_runtime_x86.msi - twice and then again twice for vc_runtime_x64.msi. However, the message at the end of the installation was not what I wanted to see: Reapplication did not succeed. The very same a few times I tried it again and again.

VS 2010 SP1 log reads:

Final Result: Installation failed with error code: (0x80070643), "Fatal error during installation. " (Elapsed time: 0 00:33:06).

The big SP1 log contains links to logs of all setup it runs, including setup for Silverlight 4 SDK and VC++ runtimes.

The log for Silverlight 4 SDK:

MSI (c) (DC:98) [16:40:02:132]: SOURCEMGMT: Trying source E:\Silverlight4\1033.
MSI (c) (DC:98) [16:40:02:231]: Cloaking enabled.
MSI (c) (DC:98) [16:40:02:232]: Attempting to enable all disabled privileges before calling Install on Server
MSI (c) (DC:98) [16:40:02:232]: Connected to service.
MSI (c) (DC:14) [16:40:02:253]: SOURCEMGMT: Resolved source to: 'E:\Silverlight4\1033\'
MSI (s) (EC:10) [16:40:02:259]: Product: Microsoft Silverlight 4 SDK -- Error 1706.No valid source could be found for product Microsoft Silverlight 4 SDK.  The Windows Installer cannot continue.

Error 1706.No valid source could be found for product Microsoft Silverlight 4 SDK.  The Windows Installer cannot continue.

The solution is to manually uninstall Silverlight 4 SDK and Visual C++ runtimes (both 32- and 64-bit flavors) from the Programs and Features Control Panel applet (aka Add Remove Programs).

And then

NHibernate lowercase and underscore automap convention

Sun, 20 Feb 2011 00:26:21 +0200

Today just a small snippet of code. If you unlucky one inherited some brownfield database with awkward lowercase_and_underscores naming convention (I really hate it):

and you are using NHibernate with Fluent automapping configuration, just use this property convention:


private class ColumnConvention : IPropertyConvention
{
    public void Apply(FluentNHibernate.Conventions.Instances.IPropertyInstance instance)
    {
        var regexString = @"([A-Z][\w^[A-Z]]*)([A-Z][\w^[A-Z]]*)*";

        var newName = Regex.Replace(instance.Name, regexString, (m => (m.Index != 0 ? "_" : "") + m.Value.ToLower()));

        instance.Column(newName);
    }
}

Of course, the real gem here is the regex itself (days without writing regexes are awesome).

If you forgot how to apply a custom convention, here you go:


SessionFactory =
    Fluently.Configure().Database(
        MsSqlConfiguration.MsSql2008.ConnectionString(c => c.FromConnectionStringWithKey("SugarCrmDb"))).
        Mappings(
            m => m.AutoMappings.Add(AutoMap.
                                        AssemblyOf(cfg).
                                        Override(am => am.Table("accounts")).
                                        Conventions.Add(new ColumnConvention())
                        )
        ).
        BuildSessionFactory();

If you really don’t know what is this all about, take a read here.

Exam 70-516 objectives with MSDN links

Thu, 06 Jan 2011 23:08:53 +0200

As I’m preparing for the 70-516 (TS: Accessing Data with Microsoft .NET Framework 4) I will be publishing and updating the list of the exam objectives together with MSDN links.

Modeling Data (20%)

Map entities and relationships by using the Entity Data Model.
This objective may include but is not limited to: using the Visual Designer, building an entity data model from an existing database, managing complex entity mappings in EDMX, editing EDM XML, mapping to stored procedures, creating user-defined associations between entities, generating classes with inheritance and mapping them to tables
This objective does not include: using MetadataWorkspace
Map entities and relationships by using LINQ to SQL.

This objective may include but is not limited to: using the Visual Designer, building a LINQ to SQL model from an existing database, mapping to stored procedures
Create and customize entity objects.

This objective may include but is not limited to: configuring changes to an Entity Framework entity, using the ADO.NET EntityObject Generator (T4), extending, self-tracking entities, snapshot change tracking, ObjectStateManager, partial classes, partial methods in the Entity Framework
Connect a POCO model to the Entity Framework.
This objective may include but is not limited to: implementing the Entity Framework with persistence ignorance, user-created POCO entities
This objective does not include: using the POCO templates
Create the database from the Entity Framework model.

This objective may include but is not limited to: customizing the Data Definition Language (DDL) (templates) generation process, generating scripts for a database, Entity Data Model tools
Create model-defined functions.

This objective may include but is not limited to: editing the Conceptual Schema Definition Language CSDL, enabling model-defined functions by using the EdmFunction attribute, complex types

Managing Connections and Context (18%)

Configure connection strings and providers.
This objective may include but is not limited to: managing connection strings including Entity Framework connection strings, using the ConfigurationManager, correctly addressing the Microsoft SQL Server instance, implementing connection pooling, managing User Instance and AttachDBfilename, switching providers, implementing multiple active result sets (MARS)
This objective does not include: using the ConnectionStringBuilder; Oracle data provider; creating and using a custom provider; using third-party providers
Create and manage a data connection.

This objective may include but is not limited to: connecting to a data source, closing connections, maintaining the life cycle of a connection
Secure a connection.
This objective may include but is not limited to: encrypting and decrypting connection strings, using Security Support Provider Interface (SSPI) or SQL Server authentication, read only vs. read/write connections
This objective does not include: Secure Sockets Layer (SSL)
Manage the DataContext and ObjectContext.

This objective may include but is not limited to: managing the life cycle of DataContext and ObjectContext, extending the DataContext and ObjectContext, supporting POCO
Implement eager loading.
This objective may include but is not limited to: configuring loading strategy by using LazyLoadingEnabled, supporting lazy loading with POCO, explicitly loading entities
Cache data.
This objective may include but is not limited to: DataContext and ObjectContext cache including identity map, local data cache
This objective does not include: Velocity, SqlCacheDependency
Configure ADO.NET Data Services.

This objective may include but is not limited to: creating access rules for entities, configuring authorization and authentication (and WCF Data Services Team Blog), configuring HTTP verbs

Querying Data (22%)

Execute a SQL query.

This objective may include but is not limited to: DBCommand, DataReader, DataAdapters, DataSets, managing data retrieval by using stored procedures, using parameters, System.Data.Common namespace classes
Create a LINQ query.
This objective may include but is not limited to: syntax-based and method-based queries, joining, filtering, sorting, grouping, aggregation, lambda expressions, paging, projection
This objective does not include: compiling queries
Create an Entity SQL (ESQL) query.

This objective may include but is not limited to: joining, filtering, sorting, grouping, aggregation, paging, using functions, query plan caching, returning a reference to an entity instance, using parameters with ESQL, functionality related to EntityClient classes
Handle special data types.
This objective may include but is not limited to: querying BLOBs, filestream, spatial and table-valued parameters
This objective does not include: implementing data types for unstructured data, user-defined types, Common Language Runtime (CLR) types
Query XML.
This objective may include but is not limited to: LINQ to XML, XmlReader, XmlDocuments, XPath
This objective does not include: XSLT, XmlWriter
Query data by using ADO.NET Data Services.

This objective may include but is not limited to: implementing filtering and entitlement in ADO.NET Data Services, addressing resources, creating a query expression, accessing payload formats, Data Services interceptors

Manipulating Data (22%)

Create, update, or delete data by using SQL statements.

This objective may include but is not limited to: Create/Update/Delete (CUD), using DataSets, calling stored procedures, using parameters
Create, update, or delete data by using DataContext.
This objective may include but is not limited to: CUD, calling stored procedures, using parameters
This objective does not include: ObjectTrackingEnabled
Create, update, or delete data by using ObjectContext.

This objective may include but is not limited to: CUD, calling stored procedures, using parameters, setting SaveOptions
Manage transactions.
This objective may include
but is not limited to: System.Transactions, DBTransaction, rolling back a transaction, Lightweight Transaction Manager (LTM)

This objective does not include: distributed transactions, multiple updates within a transaction, multiple synchronization of data within an acidic transaction
Create disconnected objects.

This objective may include but is not limited to: creating self-tracking entities in the Entity Framework, attaching objects, DataSets, table adapters

Developing and Deploying Reliable Applications (18%)

Monitor and collect performance data.

This objective may include but is not limited to: logging generated SQL (ToTraceString), collecting response times, implementing performance counters, implementing logging, implementing instrumentation
Handle exceptions.

This objective may include but is not limited to: resolving data concurrency issues (handling OptimisticConcurrency exception, Refresh method), handling errors, transaction exceptions, connection exceptions, timeout exceptions, handling an exception from the Entity Framework disconnected object, security exceptions
Protect data.

This objective may include but is not limited to: encryption, digital signature, hashing, salting, least privilege
Synchronize data.

This objective may include but is not limited to: online/offline Entity Framework, synchronization services, saving locally
Deploy ADO.NET components.

This objective may include but is not limited to: packaging and publishing from Visual Studio, deploying an ADO.NET Services application; packaging and deploying Entity Framework metadata

This objective does not include: configuring IIS, MSDeploy, MSBuild