Gil Fink's Blog : Tools

Which Development Product will You Suggest Your Boss?

Gil Fink — Thu, 17 Feb 2011 19:16:00 GMT

Which Development Product will You Suggest Your Boss?

Today I was asked to help in a decision making of buying products for developers in a company that I’m consulting for. The manager gave me the information about his budget and asked for suggestions. I suggested two products which doesn’t exists in the arsenal of tools at that company – one for developers productivity and refactoring and the second for profiling the developers products.

If you got a budget for buying a product for developers, which product will you suggest to your boss to buy and why?

.NET Reflector is Becoming a Paid-For Product

Gil Fink — Thu, 03 Feb 2011 14:05:03 GMT

.NET Reflector is Becoming a Paid-For Product

Red Gate announced a few days ago that .NET Reflector will become a commercial product from the end of February 2011. Here is what Neil Davidson, Red Gate’s Co-CEO, wrote as an open letter to the .NET community:

”Red Gate has announced that it will charge $35 for version 7 of .NET Reflector upon its release in early March. Version 7 will be sold as a perpetual license, with no time bomb or forced updates.

As many of you know, our original intention was to maintain .NET Reflector as a free tool. But, after two-and-a-half years of providing it without charge, we realized that we could not make the free model work. We know that this will cause pain for some people in the .NET community, and we apologize for the change in policy.

As a commercial company, we need to charge at least a nominal amount to keep .NET Reflector up-to-date and relevant. Without revenue coming in, we cannot dedicate a team of developers to ensure that Reflector remains a valuable part of .NET developers’ toolboxes.

As always, your feedback is important to Red Gate, so please contribute any thoughts on this subject to our .NET Reflector forum.

Sincerely,
Neil Davidson
Co-CEO, Red Gate Software”

Since Red Gate bought .NET Reflector I expected this change to come. But what I didn’t expected is that the product will have no free version at all. This is bad news for the people who use it on a daily basis (like I do). I know that $35 isn’t a lot of money but I want to refer you to Lutz Roeder’s announcement when he sold .NET Reflector to Red Gate – “Red Gate will continue to provide the free community version and is looking for your feedback and ideas for future versions.”

What do you think about this Red Gate announcement?

Detecting HTML5 Features Using Modernizr

Gil Fink — Mon, 10 Jan 2011 01:27:42 GMT

Detecting HTML5 Features Using Modernizr

In the past I wrote a post about using feature detection instead of browser detection when writing web applications/sites. There are frameworks like jQuery that do that for you and all you have to do is to use them. There are other frameworks like Modernizr that are specializing in testing the current browser you use in order to detect whether it supports upcoming features such as HTML5 or CSS3.

What is Modernizr?

Taken from Modernizr site: “Modernizr is a small and simple JavaScript library that helps you take advantage of emerging web technologies (CSS3, HTML 5) while still maintaining a fine level of control over older browsers that may not yet support these new technologies.”

How to use the Modernizr?

Using Modernizr is very easy. First download the library from Modernizr’s site. Then add the javascript file you downloaded to your site and use Moderinzr API. For example, here is how you’ll detect whether HTML5 Canvas is available in the browser:

       // In your BLOCKED SCRIPT

      if (Modernizr.canvas) {

         var c = document.createElement('canvas');

         var context = c.getContext('2d');    

         // Do your work 

      }

Here is an example of detecting search input type:

      <input type="search" name="searchBox" id="searchBox">

      <script>  

      if (!Modernizr.inputtypes.search){

        // if no native support, create your own search box

        createSearchBox(document.getElementById('searchBox'));

      }

      </script>

Here is a check for SVG:

      if (Modernizr.svg)

      {

          // SVG is supported by your browser

      } else 

      {

          // SVG is not supported

      }

As you can see the API is very easy to use and easy to pick up. For further information about the API you can go to Modernizr’s documentation.

Summary

Feature detection can help you to create a more stable web application/site. Modernizr is a javascript library that can help you to detect upcoming features such as HTML5 or CSS3. It is very easy to use and can be downloaded from here.

EFProf – Profiler Tool for Entity Framework

Gil Fink — Thu, 12 Aug 2010 13:53:20 GMT

EFProf – Profiler Tool for Entity Framework

One of the important tools in your tool arsenal when you develop with an ORM tool
is a profiler. Like SQL profiler to a SQL Server DBA an Entity Framework profiler is a must have tool to Entity Framework developer.
The main reasons to acquire such a tool are to understand what is going on underneath the hood in the query engine and for performance tuning. If you think that you can use Entity Framework without knowing what it is committing to database then you should think again. Things like select N+1 or avoiding too many joins will get back at you during runtime and kick you in the face.

EFProf is an Entity Framework profiler from Hibernating Rhinos.
It includes a very intuitive views/reports and supply a lot of valuable information about what is going on when you use Entity Framework. It also provides a lot of performance alerts which can lead you to find bottle necks or problems in writing the data access queries. Behind the tool you can find Oren Eini (Ayende) which is very known for his support for NHibernate and he brings tones of knowledge in the ORMs world to the tool.

How to Get Started with EFProf

When you want to use EFProf you first need to do the following things:

Add reference to the HibernatingRhinos.Profiler.Appender dll in your application.
The dll can be found in the tool folder.

In the application start you will call the following line of code:

         HibernatingRhinos.Profiler.Appender.EntityFramework.EntityFrameworkProfiler.Initialize();
      

Now start the profiler application and then run your application and get the profiler input.

Easy as that.

Using the Tool

When you start the profiler you will get the following screen:

After I configured my test application and ran it I got the following screen with all the information I needed:

You can see the queries that I run at the bottom, application statistic at the left menu and more important stuff which gives you very crucial details about your running application. You can also get analysis of your code in the left menu such as:

One feature that I really liked and made me feel like a DBA was the ability to see the query plan of the query in a visual way:

And of course the ability to run your queries from the profiler:

The tool also supports alerts about common mistakes that you can do when you program against an ORM.

Summary

Profiling your application is a very important aspect for gaining better performance and learning what you are doing in code when you use a tool that you didn’t write. Blind development without understanding what is going inside a development tool is something that will get back at you after deployment. EFProf supply the insight on what is going on and is a very helpful tool to have.
As a last word, since EFProf is a commercial tool this is my opinion that is expressed in this post and I wasn’t contact by Hibernating Rhinos.

Web Platform Installer – Web Installation on Steroids

Gil Fink — Sun, 08 Aug 2010 13:16:00 GMT

Web Platform Installer – Web Installation on Steroids

One of the most annoying things that I’m sometimes
get stuck with is to install my machine with the latest
components. Trying to grab all the installation packages
for every application or library that I need can be a
very painful thing and also consumes a lot of time.
This is the reason that a tool like Web Platform
Installer was very welcome to my arsenal of tools.
In the post I’ll describe what is the Web Platform Installer and show a scenario of installation.

Web Platform Installer

As I wrote at the beginning of the post, installation can be a very painful thing. The Web Platform Installer is a tool provided by Microsoft to ease this process when we install Microsoft Web Platform. You can download it from here.
So what is this tool?
Taken from Microsoft’s site - “The Microsoft Web Platform Installer 2.0 (Web PI) is a free tool that makes getting the latest components of the Microsoft Web Platform, including Internet Information Services (IIS), SQL Server Express, .NET Framework and Visual Web Developer easy. The Web PI also makes it easy to install and run the most popular free web applications for blogging, content management and more with the built-in Windows Web Application Gallery.”. The current version of the tool is 2.0.

Using the Web Platform Installer

After you install the Web Platform Installer you can run it and install your desired components. You should have a connection to the internet in order to use the installer. When first started the Web Platform Installer will go to the web and check for the latest Web Platform products. Then the main screen will be opened:

In the screen you can choose the relevant components that you like. You can use the following tabs to choose components by categories:

What’s New? – shows all the new components available.
Web Platform – enables the installation of web servers, frameworks and runtime, databases and tools.
Web Applications – enables the installation of web applications such as DotNetNuke, WordPress, BlogEngine.Net and many more web applications.

You only need to select the components and then press the Install button in order to install them. You also have the ability to customize your installation. For example go to the Web Platform tab:

In the Web Server press the Customize link:

Now you can customize the server that will be installed.
After Choosing the components press the Install button and that is it the products will be installed.

In some components you will need to configure things. For example I installed the BlogEngine.Net and after the installation inside the Web Platform Installer I had to configure the web site for the BlogEngine.Net. So you get the help from the platform even in these parts.

Summary

If you haven’t installed the Web Platform Installer go and grab it from here. This tool is very useful and helpful and it can help you to save a lot of time and headaches.

OData Explorer

Gil Fink — Tue, 06 Jul 2010 15:46:55 GMT

OData Explorer

One nice tool to use with OData is the
OData Explorer. The OData Explorer
is a tool that helps to explore OData feeds
in a visual way and not by exploring the
Atom/JSON responses. You can download
the tool from here. Another way to use the
tool is by going to the following link:
http://Silverlight.net/ODataExplorer.

OData Explorer Requirements

The tool is a Silverlight 4 project.
In order to use it you’ll have to answer these requirements:

Visual Studio 2010
Silverlight 4 Developer runtime
Silverlight 4 SDK
Silverlight 4 tools for Visual Studio
Latest Silverlight Toolkit release for Silverlight 4

or of course use it on-line in the link I provided previously.

Using the Tool

When the tool start you’ll get to the Add New OData Workspace view:

Here you can address your feed or address public OData feeds.
After choosing the workspace you’ll get into the tool:

Now you can go over the collections (entity sets) and get their information
in grid representation (which can be edited if the service is updatable):

or in row data (Atom/JSON):

You can type your own queries in the upper text box or you can
use the Build Query view to create a query:

Summary

The OData Explorer is very useful tool when you want to
understand and look at OData feeds without understanding the
protocol. It comes with very nice features and can be very handy
in presenting your feeds.

Wireless Notebook Presenter Mouse 8000

Gil Fink — Thu, 06 May 2010 18:24:06 GMT

Wireless Notebook Presenter Mouse 8000

A few months ago I bought
a new mouse. I needed
a mouse that could also
act as a presenter tool
in order to assist me in
my presentations that I
am delivering from time to
time. So I talked to some
people and asked for their
recommendations.
I also searched for details
about presenter tools in the internet and in the end I found the
Wireless Notebook Presenter Mouse 8000 very suiting for my
needs.

The Wireless Notebook Presenter
Mouse 8000 is more then just a
mouse. It’s integrated with slide
presenter, laser pointer, and media
remote control. At the back of the
mouse we have buttons that
help us to control power point
presentations. Those buttons are
disabled by default and can be
enabled by clicking a button on
the mouse’s front.
Using the product helped me to
stop coming back to the podium
in order to press buttons during my presentations and also since this
is a mouse I could use it in my demos and of course in other
occasions which doesn’t include presentations (such as working
at the office).

So if you are looking for a slide presenter which can act as a mouse
the Wireless Notebook Presenter Mouse 8000 can suit your needs.
For further details about it go to this link.

The Regulator

Gil Fink — Tue, 02 Feb 2010 13:37:00 GMT

The Regulator

Yesterday, I reviewed a regular expression that
was written by one of the developers and
I needed to improve it since it wasn’t performing
the appropriate thing. Since I know The Regulator
tool, I opened it and in 5 minutes I came up with this
regular expression which validate Israeli phone/cellular
numbers:

^0(5[012345678]|6[47]|[23489]){1}(\-)?[^0\D]{1}\d{6}$

With The Regulator I created and checked the expression and
then implemented it in the application.

What is The Regulator?

The Regulator is a free tool that was written by Roy Osherove.
It’s purpose is to help us create regular expressions and also
to test them inside The Regulator application. It allows the
building and verifying of regular expressions and also includes
testing functionality that enable us to see a display of the hierarchical
tree that will be generated by match, replace and split operations.
The following screen show the main screen of The Regulator:

Where Can You Download It?

You can download the tool from here.

Enjoy!

Reading a Xml File in T4 Templates

Gil Fink — Sat, 12 Dec 2009 18:46:47 GMT

Reading a Xml File in T4 Templates

After I wrote the
post about the
use of T4 templates
in EF4, I played with
them for a while (not
in EF but generally with
T4 templates).
In an old project that
I’ve created almost 3 years ago
which automated the use of lookup tables I had an enum.
That enum was meant to be the connection between an Xml
node names and was heavily used in the application.
For each Xml node I needed to add an entry in the enum.
So I thought what the hell lets see if I could have make it using
a T4 template. The result is in the post.

Reading a Xml File in T4 Templates

The first thing to do is to add a new file with the extension of
.tt into the project. After I had that T4 template file I started to
think what is the way to read an Xml file from the T4. Since the
Xml file was a part of the project the use of Path class to get the
absolute location was one way to get the file.
Pay attention that if you will open the solution from the IDE and
not from its location (double click on the solution from its current
location) the Path.GetFullPath won’t work.
After I had the file it was as simple as to read a Xml using
XmlDocument and XPath query.
The following example is the T4 I have created:

     <#@ template language="C#" #>

    <#@ assembly name="System.Core" #>

    <#@ assembly name="System.Xml" #>

    <#@ import namespace="System.Xml" #>

    <#@ import namespace="System.Collections.Generic" #>

    <#@ import namespace="System.IO" #>

    using System;

    namespace Examples

    {

        public class ExampleClass

        {

            #region Enums

            public enum eExampleEnum

            {

    <#

        foreach (string name in this.GetNames())   

        {

    #>

        <#= name #>,

    <# 

        }

            #>

            }

            #endregion

        }

    }

    <#+

        public List<string> GetNames()

        {

            List<string> result = new List<string>(); 

            XmlDocument doc = new XmlDocument();

            string absolutePath = Path.GetFullPath("File.xml");                

            doc.Load(absolutePath);

            foreach (XmlNode node in doc.SelectNodes("/Root/Element"))

            {

                result.Add(node.Attributes["Name"].InnerText);

            }

            return result;

        }

    #>

Summary

The use of T4 template can help us to generate code using
a code generation tool. In the example I showed how you can use
a T4 template in order to generate an enum from a given Xml file.

T4 Templates in Entity Framework 4

Gil Fink — Sat, 05 Dec 2009 20:40:22 GMT

T4 Templates in Entity Framework 4

T4 templates or
Text Template
Transformation Toolkit is
a mean of creating a code
generation artifacts which
can save a lot of time.
This technology is a part of
Visual Studio since 2005 but
was one of those technologies
that were kept in secret by Microsoft.
Almost all the code generation stuff that is being used
in Visual Studio in technologies such as MVC, Entity Framework,
LINQ to SQL and many other use those templates as backbone
to generate code. In this post I’m going to show one of the
new features of EF4 which is the use of T4 templates to extend
or manipulate the code generation. If you like to read more about
T4 templates I recommend Scott Hanselman’s post –
T4 (Text Template Transformation Toolkit) Code Generation -
Best Kept Visual Studio Secret which has many references to good
reading stuff.

T4 Templates in Entity Framework 4 Example

In EF4 we can use T4 templates to extend and manipulate the
code generation. In the example I start with a very simple
console application. That application has a Entity Data Model
which is the same School model that I used for all my previous
EF posts:

Adding a T4 Template

Now lets explore the process of using the T4 templates.
In order to use the T4 templates, from the Entity Framework
Designer surface use the right mouse button to open the menu
and choose the Add Code Generation Item menu item:

This will open the Add New Item window that holds only EF4 T4
templates:

As you can see I have two T4 templates that I can generate. I choose the
ADO.NET EntityObject Generator. A security warning will be popping up to
check if you trust the source that generated the T4.

I choose to continue and a new file with the extension .tt is added to
the solution.

When you observe the generated .tt file you can see that all the generated
stuff of EF is located in a new .cs file that is attached to it. When opening
the SchoolModel.Designer.cs file that is attached to the edmx file you will
see a comment that say it is no longer being used:

     // Default code generation is disabled for model 'path\SchoolModel.edmx'. 

    // To enable default code generation, change the value of the 'Code Generation Strategy' designer

    // property to an alternate value. This property is available in the Properties Window when the model is

    // open in the designer.

Now that we have our own code generation file we can start manipulating
the generated code.

Manipulating Generated Code Using a T4 Template

Say for example that I want to remove the generated OnContextCreated
method which is called from the ObjectContext’s constructors:

    /// <summary>

        /// No Metadata Documentation available.

        /// </summary>

        public partial class SchoolEntities : ObjectContext

        {

            #region Constructors

            /// <summary>

            /// Initializes a new SchoolEntities object using the connection string found in the 'SchoolEntities' section of the application configuration file.

            /// </summary>

            public SchoolEntities() : base("name=SchoolEntities", "SchoolEntities")

            {

                this.ContextOptions.LazyLoadingEnabled = true;

                OnContextCreated();

            }

            /// <summary>

            /// Initialize a new SchoolEntities object.

            /// </summary>

            public SchoolEntities(string connectionString) : base(connectionString, "SchoolEntities")

            {

                this.ContextOptions.LazyLoadingEnabled = true;

                OnContextCreated();

            }

            /// <summary>

            /// Initialize a new SchoolEntities object.

            /// </summary>

            public SchoolEntities(EntityConnection connection) : base(connection, "SchoolEntities")

            {

                this.ContextOptions.LazyLoadingEnabled = true;

                OnContextCreated();

            }

            #endregion

            #region Partial Methods

            partial void OnContextCreated();

            #endregion

            #region ObjectSet Properties

            /// <summary>

            /// No Metadata Documentation available.

            /// </summary>

            public ObjectSet<Course> Courses

            {

                get

                {

                    if ((_Courses == null))

                    {

                        _Courses = base.CreateObjectSet<Course>("Courses");

                    }

                    return _Courses;

                }

            }

            private ObjectSet<Course> _Courses;

            /// <summary>

            /// No Metadata Documentation available.

            /// </summary>

            public ObjectSet<Department> Departments

            {

                get

                {

                    if ((_Departments == null))

                    {

                        _Departments = base.CreateObjectSet<Department>("Departments");

                    }

                    return _Departments;

                }

            }

            private ObjectSet<Department> _Departments;

            /// <summary>

            /// No Metadata Documentation available.

            /// </summary>

            public ObjectSet<Enrollment> Enrollments

            {

                get

                {

                    if ((_Enrollments == null))

                    {

                        _Enrollments = base.CreateObjectSet<Enrollment>("Enrollments");

                    }

                    return _Enrollments;

                }

            }

            private ObjectSet<Enrollment> _Enrollments;

            /// <summary>

            /// No Metadata Documentation available.

            /// </summary>

            public ObjectSet<Person> People

            {

                get

                {

                    if ((_People == null))

                    {

                        _People = base.CreateObjectSet<Person>("People");

                    }

                    return _People;

                }

            }

            private ObjectSet<Person> _People;

            #endregion

            #region AddTo Methods

            /// <summary>

            /// Deprecated Method for adding a new object to the Courses EntitySet. Consider using the .Add method of the associated ObjectSet&lt;T&gt; property instead.

            /// </summary>

            public void AddToCourses(Course course)

            {

                base.AddObject("Courses", course);

            }

            /// <summary>

            /// Deprecated Method for adding a new object to the Departments EntitySet. Consider using the .Add method of the associated ObjectSet&lt;T&gt; property instead.

            /// </summary>

            public void AddToDepartments(Department department)

            {

                base.AddObject("Departments", department);

            }

            /// <summary>

            /// Deprecated Method for adding a new object to the Enrollments EntitySet. Consider using the .Add method of the associated ObjectSet&lt;T&gt; property instead.

            /// </summary>

            public void AddToEnrollments(Enrollment enrollment)

            {

                base.AddObject("Enrollments", enrollment);

            }

            /// <summary>

            /// Deprecated Method for adding a new object to the People EntitySet. Consider using the .Add method of the associated ObjectSet&lt;T&gt; property instead.

            /// </summary>

            public void AddToPeople(Person person)

            {

                base.AddObject("People", person);

            }

            #endregion

        }

Opening the .tt file and then removing the OnContextCreated
method call from the constructors and also the generation of the
OnContextCreated partial method will result in the following
ObjectContext:

    /// <summary>

    /// No Metadata Documentation available.

    /// </summary>

    public partial class SchoolEntities : ObjectContext

    {

        #region Constructors

        /// <summary>

        /// Initializes a new SchoolEntities object using the connection string found in the 'SchoolEntities' section of the application configuration file.

        /// </summary>

        public SchoolEntities() : base("name=SchoolEntities", "SchoolEntities")

        {

            this.ContextOptions.LazyLoadingEnabled = true;

        }

        /// <summary>

        /// Initialize a new SchoolEntities object.

        /// </summary>

        public SchoolEntities(string connectionString) : base(connectionString, "SchoolEntities")

        {

            this.ContextOptions.LazyLoadingEnabled = true;

        }

        /// <summary>

        /// Initialize a new SchoolEntities object.

        /// </summary>

        public SchoolEntities(EntityConnection connection) : base(connection, "SchoolEntities")

        {

            this.ContextOptions.LazyLoadingEnabled = true;

        }

        #endregion

        #region ObjectSet Properties

        /// <summary>

        /// No Metadata Documentation available.

        /// </summary>

        public ObjectSet<Course> Courses

        {

            get

            {

                if ((_Courses == null))

                {

                    _Courses = base.CreateObjectSet<Course>("Courses");

                }

                return _Courses;

            }

        }

        private ObjectSet<Course> _Courses;

        /// <summary>

        /// No Metadata Documentation available.

        /// </summary>

        public ObjectSet<Department> Departments

        {

            get

            {

                if ((_Departments == null))

                {

                    _Departments = base.CreateObjectSet<Department>("Departments");

                }

                return _Departments;

            }

        }

        private ObjectSet<Department> _Departments;

        /// <summary>

        /// No Metadata Documentation available.

        /// </summary>

        public ObjectSet<Enrollment> Enrollments

        {

            get

            {

                if ((_Enrollments == null))

                {

                    _Enrollments = base.CreateObjectSet<Enrollment>("Enrollments");

                }

                return _Enrollments;

            }

        }

        private ObjectSet<Enrollment> _Enrollments;

        /// <summary>

        /// No Metadata Documentation available.

        /// </summary>

        public ObjectSet<Person> People

        {

            get

            {

                if ((_People == null))

                {

                    _People = base.CreateObjectSet<Person>("People");

                }

                return _People;

            }

        }

        private ObjectSet<Person> _People;

        #endregion

        #region AddTo Methods

        /// <summary>

        /// Deprecated Method for adding a new object to the Courses EntitySet. Consider using the .Add method of the associated ObjectSet&lt;T&gt; property instead.

        /// </summary>

        public void AddToCourses(Course course)

        {

            base.AddObject("Courses", course);

        }

        /// <summary>

        /// Deprecated Method for adding a new object to the Departments EntitySet. Consider using the .Add method of the associated ObjectSet&lt;T&gt; property instead.

        /// </summary>

        public void AddToDepartments(Department department)

        {

            base.AddObject("Departments", department);

        }

        /// <summary>

        /// Deprecated Method for adding a new object to the Enrollments EntitySet. Consider using the .Add method of the associated ObjectSet&lt;T&gt; property instead.

        /// </summary>

        public void AddToEnrollments(Enrollment enrollment)

        {

            base.AddObject("Enrollments", enrollment);

        }

        /// <summary>

        /// Deprecated Method for adding a new object to the People EntitySet. Consider using the .Add method of the associated ObjectSet&lt;T&gt; property instead.

        /// </summary>

        public void AddToPeople(Person person)

        {

            base.AddObject("People", person);

        }

        #endregion

    }

Of course this is silly to do because this is an extension point
when the context is being created but for the example it is enough
to show the power of the T4 templates.

Summary

The T4 templates enables us to implement code generation.
When you have something that you do manually more then one time
then applying a T4 template can help you to make it automatic.
As I show in the post, EF4 is shipping with a way to manipulate the
code generation using T4 templates. Next time when something bother
you in the EF generated code you can do something about it.

Using External Configuration File for Enterprise Library Configuration

Gil Fink — Sun, 15 Nov 2009 20:55:00 GMT

Using External Configuration File for Enterprise Library Configuration

One of the things
that I always do when
I’m using Enterprise
Library is to separate
its configurations to
external configuration file.
The reason is very obvious – using Enterprise Library makes
configuration files very crowded. Since this is the case, the
configuration files become unmanageable and then its time to
separate the Enterprise Library’s configurations from other
configurations.

How to Use external Configuration File for Enterprise Library Configuration?

It is very simple to separate the Enterprise Library configurations
to another external file.

Step 1
Create a new configuration file in the solution which is going to
hold the Enterprise Library configurations. In my solution I added
a new EL.config file in the root of the project along side for the
web.config.

Step 2
From Enterprise Library Configuration Tool add a new Configuration
Sources node.

Step 3
In the node add a new File Configuration Source with
the name you want to give the file.

Give it a relevant name such as EntLib Configuration Source.

Step 4
In the properties of the created File Configuration Source add the
path to the file which can be full path or relative path. I prefer the
relative path.

Since my file sits in the root of the project I only have to write
its name and it will be given a relative path. If for example I put it
in a Configuration directory I’ll have to write Configuration/EL.config.

Step 5
Make the new File Configuration Source the selected source and
that is it.

After doing so all the Enterprise Library configurations
will sit in the file configuration source and not in your web.config
enabling the separation of Ent-Lib configurations from the application
configurations. Also when you’ll open the web.config (or app.config) in
Enterprise Library Configuration Tool it’ll show the Enterprise Library
configurations and enable making changes which will be saved in the
other EL.config automatically for you.

Summary

In the post I showed how to separate the Enterprise Library configurations
to external file. This is done to increase manageability of configuration files.

New Release for VelocityAdminShell

Gil Fink — Sat, 11 Jul 2009 14:53:24 GMT

New Release for VelocityAdminShell

I’ve published a new release for the VelocityAdminShell.
This new release includes a configuration form to enable the configuration
of the shell (instead of doing it manually in the config file).
The following figure shows the current configuration form:

I also changed the look and feel of the shell and added tabs for different operation
types:

Thanks to Eyal Vardi for the inputs regarding the VelocityAdminShell.
You can download the new release of VelocityAdminShell from here.

VelocityAdminShell is Published on CodePlex

Gil Fink — Wed, 24 Jun 2009 19:01:32 GMT

VelocityAdminShell is Published on CodePlex

I’ve published the VelocityAdminShell tool that I wrote about yesterday on CodePlex.
You can download the project with its source code from here.
As I wrote, if you have any suggestions for improvement or you encounter bugs
please contact me in the blog’s contact form or from the CodePlex tool’s site.
I’ll keep on updating the tool in the near future.

Enjoy!

Velocity Administration Console

Gil Fink — Tue, 23 Jun 2009 17:34:40 GMT

Velocity Administration Console

Lately I’ve been working on a small administration console project for
Microsoft project code named Velocity. If you don’t know, Velocity’s
administration is being done with PowerShell.
I decided to build a console that will do the same thing but in Windows Forms.
The following figure shows the tool I’ve built:

You can download the tool from here.

Pay attention that the project is still in develop so bugs can occur!

The following things are changes you need to do manually in the
VelocityAdminConsole.exe.config file to enable the console:

VelocityFileSystemConnectionString – if you chose to manage the cluster
in a shared network folder, put here the path to that folder.
VelocitySQLConnectionString – if you chose to manage the cluster in a
SQL Server, put here the connection string to the SQL Server.
ClusterName – put here the cluster name.
Provider – put here the provider you use.

You can expect more features like installation project in the near future.
As I wrote, the project is still in development and this is why I didn’t publish it
in CodePlex. I promise to put the project in CodePlex in the near future.
If you have any suggestions for improvement or you encounter bugs please
contact me in the blog’s contact form.
I hope you’ll find this console helpful.

Entity Framework Mapping Helper

Gil Fink — Fri, 03 Apr 2009 18:59:15 GMT

Entity Framework Mapping Helper

Entity Framework Mapping Helper
is a very useful tool that was
written by the Entity Framework
team and can help you to get started
with various of mappings scenarios.
“Entity Framework mapping helper lets you create sample mapping files
for the set of scenarios you are interested in. It’s a great tool for a deeper
understanding for how schema files are defined for complex mapping scenarios
in Entity Framework.” (The Entity Framework Mapping Helper description on
MSDN Code Gallery). You get inside of it the following mapping scenarios
examples:

Inheritance – table per hierarchy (TPH), table per type (TPT),
table per concrete type (TPC) and a mix of these inheritance
types.
Entity Splitting – vertical splitting and horizontal splitting.
Abstract types.
Multiple entity set per type (MEST).
Use of complex types.
Association within EntitySet – one to one, one to many and
self association.
Association across EntitySets – one to one, one to many and
many to many.
Use of condition element – Boolean discriminator for TPH.

Every example is described in a graphical diagram and in a separated
schema files.
You can download it from MSDN Code Gallery in the following link:
Entity Framework Mapping Helper.
Enjoy.