net-35 « WordPress.com Tag Feed

Visual Studio 2008 and .NET Framework 3.5 Training Kit

esersahin — Sat, 21 Nov 2009 07:40:55 +0000

http://www.microsoft.com/downloads/details.aspx?FamilyID=8BDAA836-0BBA-4393-94DB-6C3C4A0C98A1&displaylang=en

The Visual Studio 2008 and .NET Framework 3.5 Training Kit includes presentations, hands-on labs, and demos. This content is designed to help you learn how to utilize the Visual Studio 2008 features and a variety of framework technologies including: LINQ, C# 3.0, Visual Basic 9, WCF, WF, WPF, ASP.NET AJAX, VSTO, CardSpace, SilverLight, Mobile and Application Lifecycle Management.

Break out of WebForm_DoPostBackWithOptions Hell

Mike Malter — Wed, 28 Oct 2009 22:35:31 +0000

I have been going nuts all day trying to get a link button to fire its command event and cause a postback in a GridView control. On this particular page, whenever I click on the link, I get a WebForm_DoPostBackWithOptions instead of __doPostback, and of course I never hit the grid’s command event in my page behind.

The solution? Set causesvalidation=”false” in the link button and the command event will fire. Why, I don’t know, this just works and hopefully you’ll find this post before having to spend too many hours trying to figure it out.

ASP.NET 4 and Visual Studio 2010 Released

Vijay Modi — Thu, 22 Oct 2009 08:00:17 +0000

Today, I just visited http://ASP.Net and found that Microsoft has released ASP.Net 4 Beta 2 and Visual Studio 2010 Beta 2. You can find some of the exciting changes on the following URL:

http://www.asp.net/learn/whitepapers/aspnet4/#_TOC1_1

And you can find Breaking changes on the following URL:

http://www.asp.net/learn/whitepapers/aspnet4/breaking-changes/

Some new features are really amazing. Lets start with this new one instead of using old.

Cheers with ASP.Net 4 Beta 2
Vijay Modi

Validation on User Registration

Vijay Modi — Sun, 11 Oct 2009 13:20:52 +0000

Article moved on the following URL:

http://mysoftskill.blogspot.com/2009/11/validation-on-user-registration.html

Thanks & Regards,
Vijay Modi

Solve new page flicker in AJAX

Mike Malter — Sat, 10 Oct 2009 00:15:35 +0000

Want to stop flickering when going from one page to another in AJAX?

Put the following code in your head section:


<head runat="server">
        <meta http-equiv="Page-Enter" content="BlendTrans(Duration=.05)" />
        <meta http-equiv="Page-Exit" content="BlendTrans(Duration=.05,Translation=0)" />
</head>

For more details about these meta settings, go to http://www.aim-higher.net/meta-transitions.asp.

ASP.NET User Control events tamed through Page_PreRenderComplete

Mike Malter — Fri, 09 Oct 2009 20:36:38 +0000

Something that has been bothering me for a really long time is now under control thanks to a blog post in the .NET Geek’s Blog entry on Understanding the Page Life Cycle in ASP.NET. In a nutshell, here is the issue. I prefer to create user controls that wrap standard .NET controls and then put role enabled and other code into the controls. That code determines if the control makes it self visible or disabled along with some other nice to haves.

The problem is that when a page first draws and fires off its events, the user control events follow, and if I come into the page wanting a button to be disabled in certian instances, the user controls resolve their states after the page. So if I have a button in a user control and expose its Enabled property through a get/set variable, I can never make it stick when the page first draws.

In the source code below, I am using the Page_PreRenderComplete event to test for page state and call an appropriate method. In this case the PrepUIforAdd is called and it disables a number of buttons as well other things. If I called PrepUIforAdd in the Page_PreRender event, the buttons would never stay disabled. But calling it in the Page_PreRenderComplete event will result in the outcome I want when the page displays.

		/// <summary>
		/// PreRender is complete
		/// </summary>
		/// <param name="sender"></param>
		/// <param name="e"></param>
		protected void Page_PreRenderComplete( object sender, EventArgs e )
		{
			if ( !Page.IsPostBack )
			{
				ucErrorMessage.Clear();

				switch ( this.CurrentPageState )
				{
					case PageState.Add:
						{
							PrepUIforAdd();
							break;
						}
					case PageState.Edit:
						{
							PopulatePersonInfo();
							PopulateLinkedRoles();
							PopulateUnlinkedRoles();
							break;
						}
				}

				this.ManagePersonTabContainer.ActiveTabIndex = 0;
			}
		}

		/// <summary>
		/// Preps UI for adding a person
		/// </summary>
		private void PrepUIforAdd()
		{
			this.txtPersonID.Text = (PersonIDConstant.Everybody.ToInt()).ToString();

			this.txtLastName.Text = string.Empty;
			this.txtFirstName.Text = string.Empty;
			this.txtLogin.Text = string.Empty;
			this.txtPassword.Text = string.Empty;
			this.txtInceptionDate.Text = string.Empty;
			this.txtLastModifiedDate.Text = string.Empty;
			this.txtLastModifiedByPersonName.Text = string.Empty;
			this.ddActive.YesNoID = 1;
			this.ddDeleted.YesNoID = 0;

			lbRolesAvailable.Clear();
			lbRolesSelected.Clear();

			this.bDelete.Enabled = false;
			this.bNew.Enabled = false;
			this.bResetPassword.Enabled = false;
			this.bRoleLink.Enabled = false;
			this.bRoleUnlink.Enabled = false;

			ddEmailType.Clear();
			List<EmailCollection> dt = GetCachedEmailList();
			if ( this.ErrorLevel == Status.Success )
			{
				ddEmailType.DataSource = dt;
				ddEmailType.DataTextField = "EmailTypeName";
				ddEmailType.DataValueField = "EmailTypeID";
				ddEmailType.DataBind();
			}

			this.txtEmail.Text = GetCachedEmailAddress( PersonIDConstant.Everybody.ToInt(), ddEmailType );
		}

Populating Select Lists in ASP.NET MVC and jQuery

David Longnecker — Fri, 25 Sep 2009 15:50:26 +0000

I’ve been working the last bit to find the best way to create/populate select (option) lists using a mixture of ASP.NET MVC and jQuery. What I’ve run into is that the “key” and “value” tags are not passed along when using Json(data).

Here’s what I’m trying to pull off in jQuery: building a simple select drop down list.

var dd_activities = “<select id=’dd_activities’>”;
var count = data.length;
for (var i = 0; i < count; i++) {
dd_activities += “<option value=’” + data[i].Key + “‘>” + data[i].Value + “</option>”;
}
dd_activities += “</select>”;

$(“#activities”).before(dd_activities);

Using some very basic key/value data:

[
{"3","Text Value"},
{"4","Another Text Value"},
{"1","More boring values..."},
{"2","Running out of values"},
{"5","Last value..."}
]

Without any sort of name, I was at a loss on how to access the information, how to get it’s length, or anything. FireBug was happy to order it up… but that didn’t help.

My first attempt was to use a custom object, but that just felt dirty—creating NEW objects simply to return Json data.

My second attempt matched the mentality of newing new anonymous Json objects and seemed to work like a champ:

[Authorize]
[CacheFilter(Duration = 20)]
public ActionResult GetActivitiesList()
{
    try
    {
        var results = 
        _activityRepository
            .GetAll()
            .OrderBy(x => x.Target.Name).OrderBy(x => x.Name)
            .Select(x => new
                {
                    Key = x.Id.ToString(), 
                    Value = string.Format(“[{0}] {1}”, x.Target.Name, x.Name)
                })
            .ToList();
 
        return Json(results);
    }
    catch (Exception ex)
    {
        return Json(ex.Message);
    }
}

Well, not beautiful, but returns a sexy Key/Value list that Json expects—and that populates our select list.

[
{"Key":"3","Value":"Text Value"},
{"Key":"4","Value":"Another Text Value"},
{"Key":"1","Value":"More boring values..."},
{"Key":"2","Value":"Running out of values"},
{"Key":"5","Value":"Last value..."}
]

The next step was to get that out of the controller and into the data repository… pushing some of that logic back down to the database.

var criteria =
    Session.CreateCriteria<Activity>()
    .CreateAlias(“Target”, “Target”)
    .Add(Restrictions.Eq(“IsValid”, true))
    .AddOrder(Order.Asc(“Target.Name”))
    .AddOrder(Order.Asc(“Name”))
    .SetMaxResults(100);
 
var data = criteria.List<Activity>();
var result =
    data
        .Select(x => new
            {
                Key = x.Id.ToString(), 
                Value = string.Format(“[{0}] {1}”, x.Target.Name, x.Name)
            })
        .ToList();
tx.Commit();
return result;

A bit of formatting, restrictions, push the ordering back to the database, and a tidy SQL statement is created.

The last touch is the return type. Since we’re returning a “List” of anonymous types, the return type of GetActivitiesList() must be an IList.

That shrinks down my ActionResult to a single call.

try
 {
     return Json(_activityRepository.GetActivitiesList());
 }
 catch (Exception ex)
 {
     return Json(ex.Message);
 }

That works… and will work for now. Though, I’ve marked it as a HACK in my code. Why? I’m honestly not sure yet. Just a feeling.

Tags: asp.net+mvc, jquery, nhibernate

Calling SSIS from .Net

arcanecode — Thu, 24 Sep 2009 22:43:39 +0000

In a recent DotNetRocks show, episode 483, Kent Tegels was discussing SQL Server Integration Services and how it can be useful to both the BI Developer as well as the traditional application developer. While today I am a SQL Server BI guy, I come from a long developer background and could not agree more. SSIS is a very powerful tool that could benefit many developers even those not on Business Intelligence projects. It was a great episode, and I high encourage everyone to listen.

There is one point though that was not made very clear, but I think is tremendously important. It is indeed possible to invoke an SSIS package from a .Net application if that SSIS package has been deployed to the SQL Server itself. This article will give an overview of how to do just that. All of the sample code here will also be made available in download form from the companion Code Gallery site, http://code.msdn.microsoft.com/ssisfromnet .

In this article, I do assume a few prerequisites. First, you have a SQL Server with SSIS installed, even if it’s just your local development box with SQL Server Developer Edition installed. Second, I don’t get into much detail on how SSIS works, the package is very easy to understand. However you may wish to have a reference handy. You may also need the assistance of your friendly neighborhood DBA in setting up the SQL job used in the process.

Summary

While the technique is straightforward, there are a fair number of detailed steps involved. For those of you just wanting the overview, we need to start with some tables (or other data) we want to work with. After that we’ll write the SSIS package to manipulate that data.

Once the package is created it must be deployed to the SQL Server so it will know about it. This deploy can be to the file system or to SQL Server.

Once deployed, a SQL Server Job must be created that executes the deployed SSIS package.

Finally, you can execute the job from your .Net application via ADO.NET and a call to the sp_start_job stored procedure built into the msdb system database.

OK, let’s get to coding!

Setup the Tables

First we need some data to work with. What better than a listing of previous Dot Net Rocks episodes? I simply went to the Previous Shows page, highlighted the three columns of show number, show name, and date, and saved them to a text file. (Available on the Code Gallery site.)

Next we need a place to hold data so SSIS can work with it. I created a database and named it ArcaneCode, however any database should work. Next we’ll create a table to hold “staging” DNR Show data.

CREATE TABLE [dbo].[staging_DNRShows](
[ShowData] [varchar](250) NOT NULL
) ON [PRIMARY]

This table will hold the raw data from the text file, each line in the text file becoming one row here. Next we want a table to hold the final results.

CREATE TABLE [dbo].[DNRShows](
[ShowNumber] [int] NOT NULL,
[ShowName] [varchar](250) NULL,
[ShowDate] [datetime] NULL,
CONSTRAINT [PK_DNRShows] PRIMARY KEY CLUSTERED
(
[ShowNumber] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]

The job of the SSIS package will be to read each row in the staging table and split it into 3 columns, the show’s number, name, and date, then place those three columns into the DNRShows table above.

The SSIS Package

The next step is to create the SSIS package itself. Opening up Visual Studio / BIDS, create a new Business Intelligence SQL Server Integration Services project. First let’s setup a shared Data Source to the local server, using the ArcaneCode database as our source.

The default package name of “Package.dtsx” isn’t very informative, so let’s rename it ”LoadDNRShows.dtsx”. Start by adding a reference to the shared data source in the Connection Managers area, taking the default. Then in the Control Flow surface add 3 tasks, as seen here:

The first task is an Execute SQL Task that simply runs a “DELETE FROM dbo.DNRShows” command to wipe out what was already there. Of course in a true application we’d be checking for existing records in the data flow and doing updates or inserts, but for simplicity in this example we’ll just wipe and reload each time.

The final task is also an Execute SQL Task, after we have processed the data we no longer need it in the staging table, so we’ll issue a “DELETE FROM dbo.staging_DNRShows” to remove it.

The middle item is our Data Flow Task. This is what does the heavy lifting of moving the staging data to the main table. Here is a snapshot of what it looks like:

The first task is our OLEDB Source, it references the staging_DNRShows table. Next is what’s called a Derived Column Transformation. This will allow you to add new calculated columns to the flow, or add columns from variables. In this case we want to add three new columns, based on the single column coming from the staging table.

As you can see in under Columns in the upper left, we have one column in our source, ShowData. In the lower half we need to add three new columns, ShowNumber, ShowDate, and ShowName. Here are the expressions for each:

ShowNumber
(DT_I4)SUBSTRING(ShowData,1,FINDSTRING(ShowData,"\t",1))

ShowDate
(DT_DBDATE)SUBSTRING(ShowData,FINDSTRING(ShowData,"\t",2) + 1,LEN(ShowData) – FINDSTRING(ShowData,"\t",2))

ShowName
(DT_STR,250,1252)SUBSTRING(ShowData,FINDSTRING(ShowData,"\t",1) + 1,FINDSTRING(ShowData,"\t",2) – FINDSTRING(ShowData,"\t",1) – 1)

The syntax is an odd blend of VB and C#. Each one starts with a “(DT_”, these are type casts, converting the result of the rest of the expression to what we need. For example, (DT_I4) converts to a four byte integer, which we need because in our database the ShowNumber column was defined as an integer. You will see SUBSTRING and LEN which work like their VB counterparts. FINDSTRING works like the old POS statement, it finds the location of the text and returns that number. The “\t” represents the tab character, here the C# fans win out as the Expression editor uses C# like escapes for special characters. \t for tab, \b for backspace, etc.

Finally we need to write out the data. For this simply add an OLEDB Destination and set it to the target table of dbo.DNRShows. On the mappings tab make sure our three new columns map correctly to the columns in our target table.

Deploy the Package

This completes the coding for the package, but there is one final step we need to do. First, in the solution explorer right click on the project (not the solution, the project as highlighted below) and pick properties.

In the properties dialog, change the “CreateDeploymentUtility” option from false (the default) to True.

Now click the Build, Build Solution menu item. If all went well you should see the build was successful. It’s now time to deploy the package to the server. Navigate to the folder where your project is stored, under it you will find a bin folder, and in it a Deployment folder. In there you should find a file with a “.SSISDeploymentManifest” extension. Double click on this file to launch the Package Installation Wizard.

When the wizard appears there are two choices, File system deployment and SQL Server deployment. For our purposes we can use either one, there are pros and cons to each and many companies generally pick one or the other. In this example we’ll pick SQL Server deployment, but again know that I’ve tested this both ways and either method will work.

Once you pick SQL Server deployment, just click Next. Now it asks you for the server name, I’ve left it at (local) since I’m working with this on a development box; likewise I’ve left “Use Windows Authentication”. Finally I need the package path, I can select this by clicking the ellipse (the …) to the right of the text box. This brings up a dialog where I can select where to install.

In a real world production scenario we’d likely have branches created for each of our projects, but for this simple demo we’ll just leave it in the root and click OK.

Once your form is filled out as below, click Next.

We are next queried to what our installation folder should be. This is where SSIS will cache package dependencies. Your DBA may have a special spot setup for these, if not just click next to continue.

Finally we are asked to confirm we know what we are doing. Just click Next. If all went well, the install wizard shows us it’s happy with a report, and we can click Finish to exit.

Setup the SQL Server Job

We’ve come a long way and we’re almost to the finish line, just one last major step. We will need to setup a SQL Server Job which will launch the SSIS package for us. In SQL Server Management Studio, navigate to the “SQL Server Agent” in your Object Explorer. If it’s not running, right click and pick “Start”. Once it’s started, navigate to the Jobs branch. Right click and pick “New Job”.

When the dialog opens, start by giving your job a name. As you can see below I used LoadDNRShows. I also entered a description.

Now click on the Jobs page over on the left “Select a page” menu. At the bottom click “New” to add a new job step.

In the job step properties dialog, let’s begin by naming the step “Run the SSIS package”. Change the Type to “SQL Server Integration Services Package”. When you do, the dialog will update to give options for SSIS. Note the Run As drop down, this specifies the account to run under. For this demo we’ll leave it as the SQL Server Agent Service Account, check with your DBA as he or she may have other instructions.

In the tabbed area the General tab first allows us to pick the package source. Since we deployed to SQL Server we’ll leave it at the default, however if you had deployed to the file system this is where you’d need to change it to pick your package.

At the bottom we can use the ellipse to pick our package from a list. That done your screen should look something like:

For this demo that’s all we need to set, I do want to take a second to encourage you to browse through the other tabs. Through these tabs you can set many options related to the package. For example you could alter the data sources, allowing you to use one package with multiple databases.

Click OK to close the job step, then OK again to close the Job Properties window. Your job is now setup!

Calling from .Net

The finish line is in sight! Our last step is to call the job from .Net. To make it a useful example, I also wanted the .Net application to upload the data the SSIS package will manipulate. For simplicity I created a WinForms app, but this could easily be done in any environment. I also went with C#, again the VB.Net code is almost identical.

I started by creating a simple WinForm with two buttons and one label. (Again the full project will be on the Code Gallery site).

In the code, first be sure to add two using statements to the standard list:

using System.Data.SqlClient;

using System.IO;

Behind the top button we’ll put the code to copy the data from the text file we created from the DNR website to the staging table.

    private void btnLoadToStaging_Click(object sender, EventArgs e)
    {
      /* This method takes the data in the DNRShows.txt file and uploads them to a staging table */
      /* The routine is nothing magical, standard stuff to read as Text file and upload it to a  */
      /* table via ADO.NET                                                                      */
 
      // Note, be sure to change to your correct path
      string filename = @"D:\Presentations\SQL Server\Calling SSIS From Stored Proc\DNRShows.txt";
      string line;
 
      // If you used a different db than ArcaneCode be sure to set it here
      string connect = "server=localhost;Initial Catalog=ArcaneCode;Integrated Security=SSPI;";
      SqlConnection connection = new SqlConnection(connect);
      connection.Open();
 
      SqlCommand cmd = connection.CreateCommand();
 
      // Wipe out previous data in case of a crash
      string sql = "DELETE FROM dbo.staging_DNRShows";
      cmd.CommandText = sql;
      cmd.ExecuteNonQuery();
 
      // Now setup for new inserts
      sql = "INSERT INTO dbo.staging_DNRShows (ShowData) VALUES (@myShowData)";
 
      cmd.CommandText = sql;
      cmd.Parameters.Add("@myShowData", SqlDbType.VarChar, 255);
 
      StreamReader sr = null;
 
      // Loop thru text file, insert each line to staging table
      try
      {
        sr = new StreamReader(filename);
        line = sr.ReadLine();
        while (line != null)
        {
          cmd.Parameters["@myShowData"].Value = line;
          cmd.ExecuteNonQuery();
          lblProgress.Text = line;
          line = sr.ReadLine();
        }
      }
      finally
      {
        if (sr != null)
          sr.Close();
        connection.Close();
        lblProgress.Text = "Data has been loaded";
      }
 

Before you ask, yes I could have used any number of data access technologies, such as LINQ. I went with ADO.NET for simplicity and believing most developers are familiar with it due to its longevity. Do be sure and update the database name and path to the file in both this and the next example when you run the code.

This code really does nothing special, just loops through the text file and uploads each line as a row in the staging table. It does however serve as a realistic example of something you’d do in this scenario, upload some data, then let SSIS manipulate it on the server.

Once the data is there, it’s finally time for the grand finale. The code behind the second button, Execute SSIS, does just what it says; it calls the job, which invokes our SSIS package.

    private void btnRunSSIS_Click(object sender, EventArgs e)
    {
      string connect = "server=localhost;Initial Catalog=ArcaneCode;Integrated Security=SSPI;";
      SqlConnection connection = new SqlConnection(connect);
      connection.Open();
 
      SqlCommand cmd = connection.CreateCommand();
 
      // Wipe out previous data in case of a crash
      string sql = "exec msdb.dbo.sp_start_job N’LoadDNRShows’";
      cmd.CommandText = sql;
      cmd.ExecuteNonQuery();
      connection.Close();
      lblProgress.Text = "SSIS Package has been executed";
 
    }

The key is this sql command:

exec msdb.dbo.sp_start_job N’LoadDNRShows’

“exec” is the T-SQL command to execute a stored procedure. “sp_start_job” is the stored procedure that ships with SQL Server in the MSDB system database. This stored procedure will invoke any job stored on the server. In this case, it invokes the job “LoadDNRShows”, which as we setup will run an SSIS package.

Launch the application, and click the first button. Now jump over to SQL Server Management Studio and run this query:

select * from dbo.staging_DNRShows;

select * from dbo.DNRShows;

You should see the first query bring back rows, while the second has nothing. Now return to the app and click the “Execute SSIS” button. If all went well running the query again should now show no rows in our first query, but many nicely processed rows in the second. Success!

A few thoughts about xp_cmdshell

In researching this article I saw many references suggesting writing a stored procedure that uses xp_cmdshell to invoke dtexec. DTEXEC is the command line utility that you can use to launch SSIS Packages. Through it you can override many settings in the package, such as connection strings or variables.

xp_cmdshell is a utility built into SQL Server. Through it you can invoke any “DOS” command. Thus you could dynamically generate a dtexec command, and invoke it via xp_cmdshell.

The problem with xp_cmdshell is you can use it to invoke ANY “DOS” command. Any of them. Such as oh let’s say “DEL *.*” ? xp_cmdshell can be a security hole, for that reason it is turned off by default on SQL Server, and many DBA’s leave it turned off and are not likely to turn it on.

The techniques I’ve demonstrated here do not rely on xp_cmdshell. In fact, all of my testing has been done on my server with the xp_cmdshell turned off. Even though it can be a bit of extra work, setting up the job, etc., I still advise it over the xp_cmdshell method for security and the ability to use it on any server regardless of its setting.

In Closing

That seemed like a lot of effort, but can lead to some very powerful solutions. SSIS is a very powerful tool designed for processing large amounts of data and transforming it. In addition developing under SSIS can be very fast due to its declarative nature. The sample package from this article took the author less than fifteen minutes to code and test.

When faced with a similar task, consider allowing SSIS to handle the bulk work and just having your .Net application invoke your SSIS package. Once you do, there are no ends to the uses you’ll find for SQL Server Integration Services.

Html.Grid Rendering as Plain Text?

David Longnecker — Thu, 24 Sep 2009 03:22:43 +0000

Notice: Stupid, stupid moment described ahead. Proceed with caution.

I spent a good half hour trying to figure out why my MVCContrib Html.Grid<T> wasn’t rendering. It wasn’t throwing an error, it was simply returning the HTML code as Plain Text.

The AutoMapper code looked good,
The Html.Grid<T> code looked good (it’d be templated off another page anyway and that page was working),
The view model code looked good.

So why was I being greeted with garble junk?

${Html.Grid(Model.Details) .Attributes(Id => “RoutineDetails”) .Columns(column => { column.For(c => this.Button(“EditDetail”).Value(“Edit”).Id(string.Format(“edit_{0}”, c.Id))).DoNotEncode(); column.For(c => c.Activity.Target.Name).Named(“Target Area”); column.For(c => c.Activity.Name).Named(“Activity”); column.For(c => c.Sets); column.For(c => c.Weight); column.For(c => c.Repetitions); column.For(c => c.Duration); })}

Html.Grid that is not… well, at least not properly.

Encoding issue? Maybe. Data issue? Perhaps.

No, the issue was typing too quick and not paying attention.

public ActionResult New()
 {
     var viewModel = BuildRoutineNewViewModel(new Routine());
     return View();
 }

Yeah, that’s the problem… right there. I’d forgotten to pass the view model into the View. Apparently the Html.Grid<T> helper simply panics if the model you’re reading from is empty or null—rather than throwing an error.

Oddly enough, this is one of those times I’d wish the screen would have lit up red. Lessons learned.

Tags: mvccontrib, spark+view+engine, asp.net+mvc

ASP.NET Development Server From 'Here' in PowerShell

David Longnecker — Wed, 09 Sep 2009 16:52:21 +0000

Long title… almost longer than the code.

I used to have an old registry setting that started up the ASP.NET Development Server from the current path; however, since I rarely open up Explorer—and then opening up FireFox was even more painful—I needed a script.

What does it do?

The script starts up the ASP.NET Development server with a random port (so you can run multiples…) at your current location. It then activates your machine’s DEFAULT BROWSER and browses to the site. FireFox user? No problem. Works like a champ!

The Script (Full Code)

$path = resolve-path .
$rand = New-Object system.random
$port = $rand.next(2048,10240)
$path_to_devserver = “C:\\Program Files (x86)\\Common Files\\microsoft shared\\DevServer\\9.0\\Webdev.WebServer.exe”

& $path_to_devserver /port:$port /path:$path
(new-object -com shell.application).ShellExecute(“http:\\localhost:$port”)

The $path_to_devserver can be updated—depending on 64–bit vs. 32–bit machines. Simple, easy, and to the point. Now, no more fumbling around to launch a quick web application!

Tags: powershell, asp.net, scripts

Ramping up with PSake

David Longnecker — Tue, 08 Sep 2009 18:15:24 +0000

I’ve been tetering back and forth with PSake and my trusty NAnt scripts for quite a while now. For those not familiar with PSake, it’s build automation that makes you drunk—but in a good way. You can read James Kovacs’ original post here or check out the repository here for the latest bits.

I originally looked at rake scripts (after exposure working with Fluent NHibernate) as PowerShell is loathed in our organization—or was. That mindset is slowly changing (being able to show people how to crank out what was originally scoped at a week in two lines of PowerShell script helps out); so I’m using PSake as further motivation.

My prior PSake scripts were a bit tame. Launch msbuild, copy a few files. With the latest release of xUnit 1.5 hitting the wires over the weekend (and a much needed x86 version for my poor, cranky Oracle libraries), I decided to bite the bullet and dig in to PSake.

I had two goals:

Build a reliable framework “default.ps1” file that I could drop into almost any project and configure with little or no effort.
Compile, test, and rollout updates from a single PSake command task.

I borrowed the basic layout from Ayende’s Rhino Mocks PSake; however, I couldn’t get msbuild to run correctly simply by calling it.

Here’s what I ended up with for our internal core library. The core library, isn’t so much a “utilities” container, but just as it sounds—the framework all of our applications are built on to keep connections to our various applications (HR, student systems, data warehouses, etc) consistant as well as hold our base FNH conventions.

CODE: Full code available on CodePaste.NET

Properties

The properties area holds all of the configuration for the PSake script. For me, it’s common to configure $solution_name, $libraries_to_merge, and $libraries_to_copy. With our naming standards, the $test_library should be left unchanged. I also added in the tester information so we could change from XUnit to MBUnit (if Hell froze over or something)).

properties {

# **************** CONFIGURE ****************

       $solution_name =           “Framework”

       $test_library =            “$solution_name.Test.dll”

       $libraries_to_merge =      “antlr3.runtime.dll”, `

                                  “ajaxcontroltoolkit.dll”, `

                                  “Castle.DynamicProxy2.dll”, `

                                  “Castle.Core.dll”, `

                                  “FluentNHibernate.dll”, `

                                  “log4net.dll”, `

                                  “system.linq.dynamic.dll”, `

                                  “xunit.dll”, `

                                  “nhibernate.caches.syscache2.dll”, `

                                  “cssfriendly.dll”, `

                                  “iesi.collections.dll”, `

                                  “nhibernate.bytecode.castle.dll”, `

                                  “oracle.dataaccess.dll”



       $libraries_to_copy =       “system.data.sqlite.dll”

     $tester_directory = “j:\shared_libraries\xunit\msbuild”

       $tester_executable = “xunit.console.x86.exe”

       $tools_directory =         “$tools”

       $base_directory =         resolve-path .

       $thirdparty_directory =    “$base_directory\thirdparty”

       $build_directory =         “$base_directory\build”

       $solution_file =           “$base_directory\$solution_name.sln”

       $release_directory =       “$base_directory\release”

}

Clean and easy enough. You’ll notice that $libraries_to_merge and $libraries_to_copy are implied string arrays. That works out well since string arrays end up as params when passed to commands… and our $libraries_to_copy can be iterated over later in the code.

Tasks – Default

task default -depends Release

The default task (if just running ‘psake’ without parameters) runs Release. Easy enough.

Tasks – Clean

task Clean {

remove-item -force -recurse $build_directory -ErrorAction SilentlyContinue | Out-Null

remove-item -force -recurse $release_directory -ErrorAction SilentlyContinue | Out-Null

}

Clean up those build and release directories.

Tasks – Init

task Init -depends Clean {

    new-item $release_directory -itemType directory | Out-Null

    new-item $build_directory -itemType directory | Out-Null

    cp $tester_directory\*.* $build_directory

}

Restore those build and release directories that we cleaned up; then copy in our unit testing framework so we can run our tests (if necessary).

Tasks – Compile

task Compile -depends Init {

       # from http://poshcode.org/1050 (first lines to get latest versions)

       [System.Reflection.Assembly]::Load(‘Microsoft.Build.Utilities.v3.5, Version=3.5.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a’) | Out-Null

       $msbuild = [Microsoft.Build.Utilities.ToolLocationHelper]::GetPathToDotNetFrameworkFile(“msbuild.exe”, “VersionLatest”)



       # adding double slash for directories with spaces. Stupid MSBuild.

       &$msbuild /verbosity:minimal /p:Configuration=”Release” /p:Platform=”Any CPU” /p:OutDir=”$build_directory”\\ “$solution_file”

}

Compile is a bit tricky. As noted in the code, I ended up using a SharePoint example from PoSH code to get MSBuild to behave. The standard exec methodology provided by PSake kept ignoring my parameters. Maybe someone has an good reason.. but this works.

You also see that my OutDir has TWO slashes. It seems that directories with spaces require the second. I’m sure this will somehow bite me later on, but it seems to be working for now.

Tasks – Test

task Test -depends Compile {

$origin_directory = pwd

cd $build_directory

exec .\$tester_executable “$build_directory\$test_library”

cd $origin_directory

}

I want to thank Ayende for the idea to dump the origin directory into a parameter—brilliant. This one is pretty simple—just calls the tester and tests.

Tasks – Merge

task Merge {

       $origin_directory = pwd

       cd $build_directory



       remove-item “$solution_name.merge.dll” -erroraction SilentlyContinue

       rename-item “$solution_name.dll” “$solution_name.merge.dll”



       & $tools\ilmerge\ilmerge.exe /out:”$solution_name.dll” /t:library /xmldocs /log:”$solution_name.merge.log” `

              “$solution_name.merge.dll” $libraries_to_merge



       if ($lastExitCode -ne 0) {

              throw “Error: Failed to merge assemblies!”

       }

       cd $origin_directory

}

Merge calls ILMerge and wraps all of my libraries into one. Do I need to do this? Nah, but for the framework, I prefer to keep everything together. I don’t want to be chasing mis-versioned libraries around. Again, since $libraries_to_merge is a string array, it passes each “string” as a separate parameter—which is exactly what ILMerge wants to see.

I also have ILMerge generate and keep a log of what it did—just to have. Since the build directory gets blown away between builds (and isn’t replicated to source control), then no harm. Space is mostly free.

Tasks – Build & Release

task Build -depends Compile, Merge {

       # When I REALLY don’t want to test…

}

task Release -depends Test, Merge {

       copy-item $build_directory\$solution_name.dll $release_directory

       copy-item $build_directory\$solution_name.xml $release_directory



       # copy libraries that cannot be merged

       % { $libraries_to_copy } | %{ copy-item (join-path $build_directory $_) $release_directory }



}

Build provides just that—building with no testing and no copying to the release directory. This is more for testing out the scripts, but useful in some cases.

Release copies the library and the xml documentation out ot the release directory. It then iterates through the string array of “other” libraries (non-manged code libraries that can’t be merged, etc) and copies them as well.

Tags: powershell, msbuild, psake, visual+studio, c#

Could not load the type error "is not marked as serializable"

Udaya Kumar — Fri, 28 Aug 2009 11:34:04 +0000

There are various issues which may occur on custom application running under SharePoint ,if the appl

Playing with Shaders: Creating a water effect

marlongrech — Thu, 27 Aug 2009 15:06:03 +0000

Lately I’ve been looking at a really cool project on Codeplex for Pixel Shaders. The set of shaders in this library is awsome and really easy to use in you application….

All you need to do to consume any Shader is add a reference to the WPFShaderEffectLibrary class library and you can start using the shaders in XAML.What is really important is that you install the Shaders Build Task before trying to build the shader library (if you just add a reference to the ready build dlls you don’t even need to do this).

So let’s have a look at how we can use shaders to simulate water on screen.

This is very easy all we need is a ripple shader effect. so something like this

   1: <Window.Resources>

2:

   3:    <Storyboard x:Key="waterAnimMain">

   4:        <DoubleAnimation Storyboard.TargetName="rippleMain" Storyboard.TargetProperty="Phase" To="0" From="10" Duration="0:0:2.0"  FillBehavior="Stop" />

   5:        <DoubleAnimation Storyboard.TargetName="rippleMain" Storyboard.TargetProperty="Amplitude" To="0" From="0.6" Duration="0:0:2.0"  FillBehavior="HoldEnd" />

   6:        <DoubleAnimation Storyboard.TargetName="rippleMain" Storyboard.TargetProperty="Frequency" To="0" From="30" Duration="0:0:2.5" FillBehavior="HoldEnd" />

   7:    </Storyboard>

8:

   9: </Window.Resources>

  10: <Grid Background="Transparent" >

11:

  12:    <Border>

  13:        <Border.Background>

  14:            <LinearGradientBrush EndPoint="0.93,0.925" StartPoint="0.094,0.125">

  15:                <GradientStop Color="#FF272788" Offset="0.112"/>

  16:                <GradientStop Color="#FF090916" Offset="0.721"/>

  17:                <GradientStop Color="#FE222267" Offset="0.28"/>

  18:                <GradientStop Color="#FE131339" Offset="0.453"/>

  19:                <GradientStop Color="#FF04040A" Offset="0.974"/>

  20:            </LinearGradientBrush>

  21:        </Border.Background>

22:

  23:    </Border>

24:

  25: </Grid>

26:

  27: <Window.Effect>

  28:    <shader:RippleEffect Amplitude="0" Frequency="0" Phase="0" x:Name="rippleMain"  />

  29: </Window.Effect>

This is our Shader

   1: <shader:RippleEffect Amplitude="0" Frequency="0" Phase="0" x:Name="rippleMain"  />

And we animate this shader like so to make the effect of water

   1: <Storyboard x:Key="waterAnimMain">

   2:      <DoubleAnimation Storyboard.TargetName="rippleMain" Storyboard.TargetProperty="Phase" To="0" From="10" Duration="0:0:2.0"  FillBehavior="Stop" />

   3:      <DoubleAnimation Storyboard.TargetName="rippleMain" Storyboard.TargetProperty="Amplitude" To="0" From="0.6" Duration="0:0:2.0"  FillBehavior="HoldEnd" />

   4:      <DoubleAnimation Storyboard.TargetName="rippleMain" Storyboard.TargetProperty="Frequency" To="0" From="30" Duration="0:0:2.5" FillBehavior="HoldEnd" />

   5:  </Storyboard>

We invoke this animation by having a DispatcherTimer trigger the animation every now and then and changing the Center property of the Shader to a random point from 0 to 1.

This already gets us very close but it still does not feel like real water. The trick is to animate to ripple effects at the same time. This will make the ripple effects expand together and thus making the control which has the shader applied look like water. Yet the problem is that you can only apply ONE shader per control. BUT you can have another shader on the parent control and that would still apply the shader on all children (I explain this in this article).

   1: <Window.Resources>

2:

   3:     <Storyboard x:Key="waterAnimMain">

   4:         <DoubleAnimation Storyboard.TargetName="rippleMain" Storyboard.TargetProperty="Phase" To="0" From="10" Duration="0:0:2.0"  FillBehavior="Stop" />

   5:         <DoubleAnimation Storyboard.TargetName="rippleMain" Storyboard.TargetProperty="Amplitude" To="0" From="0.6" Duration="0:0:2.0"  FillBehavior="HoldEnd" />

   6:         <DoubleAnimation Storyboard.TargetName="rippleMain" Storyboard.TargetProperty="Frequency" To="0" From="30" Duration="0:0:2.5" FillBehavior="HoldEnd" />

   7:     </Storyboard>

8:

   9:     <Storyboard x:Key="waterAnimSub">

  10:         <DoubleAnimation Storyboard.TargetName="rippleSub" Storyboard.TargetProperty="Phase" To="0" From="10" Duration="0:0:2.0"  FillBehavior="Stop" />

  11:         <DoubleAnimation Storyboard.TargetName="rippleSub" Storyboard.TargetProperty="Amplitude" To="0" From="0.6" Duration="0:0:2.0"  FillBehavior="HoldEnd" />

  12:         <DoubleAnimation Storyboard.TargetName="rippleSub" Storyboard.TargetProperty="Frequency" To="0" From="30" Duration="0:0:2.5" FillBehavior="HoldEnd" />

  13:     </Storyboard>

14:

  15: </Window.Resources>

  16: <Grid Background="Transparent" >

17:

  18:     <Border>

  19:         <Border.Background>

  20:             <LinearGradientBrush EndPoint="0.93,0.925" StartPoint="0.094,0.125">

  21:                 <GradientStop Color="#FF272788" Offset="0.112"/>

  22:                 <GradientStop Color="#FF090916" Offset="0.721"/>

  23:                 <GradientStop Color="#FE222267" Offset="0.28"/>

  24:                 <GradientStop Color="#FE131339" Offset="0.453"/>

  25:                 <GradientStop Color="#FF04040A" Offset="0.974"/>

  26:             </LinearGradientBrush>

  27:         </Border.Background>

  28:         <Border.Effect>

  29:             <shader:RippleEffect Amplitude="0" Frequency="0" Phase="0" x:Name="ripple" Center="{Binding ElementName=main, Path=(local:MouseBehaviour.LastMouseUp)}" />

  30:         </Border.Effect>

  31:     </Border>

32:

  33:     <Grid.Triggers>

34:

  35:         <EventTrigger RoutedEvent="UIElement.MouseUp">

  36:             <BeginStoryboard Storyboard="{StaticResource waterAnim}"/>

  37:             <BeginStoryboard Storyboard="{StaticResource waterAnimMain}"/>

  38:         </EventTrigger>

  39:     </Grid.Triggers>

40:

  41:     <Grid.Effect>

  42:         <shader:RippleEffect Amplitude="0" Frequency="0" Phase="0" x:Name="rippleSub"  />

  43:     </Grid.Effect>

44:

  45: </Grid>

46:

  47: <Window.Effect>

  48:     <shader:RippleEffect Amplitude="0" Frequency="0" Phase="0" x:Name="rippleMain"  />

  49: </Window.Effect>

And that’s it. Now we have a perfect water look thanks to the Codeplex Pixel Shader library

I created a sample app that shows all this. The app also has another feature so that you can touch the water by using the mouse and the water would ripple from the point you touch (of course this is with Behaviours so that you can even reuse it )

Happy coding

DOWNLOAD SOURCE CODE

A Practical Architecture for WCF – Part 3

Mike Malter — Wed, 26 Aug 2009 20:01:35 +0000

This is the third article in our WCF practical architecture series. Part 1 is here, and part 2 is here.

At a certian point, setting up a WCF environment moves you away from programming and more toward networking. That is what this article is going to cover, how to setup a WCF client on IIS7 using the net.tcp protocol. We will be crossing machine and domain boundaries and will be suggesting a starting point for a secure environment.

We are going to do two things in this post

Configure your local development machine to host a service in IIS7
Configure a seperate server to host a service in IIS7 and to recieve what you push from your local development machine.

First, lets get service hosting done on your local machine so you have something to push to your application server. Right click on your solution and then Add and then New Web Site. Then select WCF Service as shown in the image below. I choose the name CheeseListIISHostedServices. It’s important now to pick the name you will be living with because I am recommending that this name not only be the name of your local environment, but the name of the new A record you will create to point to your application server.

Then in the AppCode folder delete the IService.cs and Service.cs files as you won’t need them because you have a seperate service layer. Next, right click your site and click on Add new ASP.NET folder, then click on Bin.

Change the name of the Service.svc folder to the name of your service. Since my service is called BrandServices, I renamed it to that. Then you will want to go into the svc file and change the Service attribute. Make sure that you include the namespace of your service too. Look at the image below for how I named my Service attribute in the svc file.

Notice in the image above that the location has been removed from the original Service.svc. We will not need this as we are going to establish a reference to the project that contains the services. To establish a reference, right click on the web site and then click on Add Reference. Go to the projects tab and then click on the project that has your services. In this instance for me it is CheeseListServices as shown in the image below.

When you click on ok, your Bin folder will get filled up with all of the referenced dll’s in your service project including your newley created services dll. Then, after a few more configuration details, you’ll have something to push out to your real services environment.

The next step is to configure the web.config file. The two things to remember about the web.config file supporting services. First it functions as the config file for the modules from the site we are wrapping with services, so all of its settings should be there, and we also have the services section. Let’s take a look at the system.serviceModel section in the web.config in the figure below to look at how to configure our service for net.tcp and to be discoverable.

You can copy and past what is here and change the names to fit your names. In the bindings section we have a netTcp binding tag. There is more here than is necessary, but this binding section will support transactions and a certian level of security. So for now just to get this running, this can be copyed and pasted.

In the services section we have three services, but two of them are collapsed because we won’t need them now, but we will later. In the service for Brand services we set our binding protocol to net.tcp and we also included a few endpoints. The mex endpoint is used by the client to generate service metadata.

Since we are not using http but net.tcp as the service protocol, we cannot put the mex endpoint address into a browser and read the file, but we will be using the WCF Test Client to make sure our setup is working. Normally, I never use the WCF Test Client because I’ll always have a client around with some sort of functionality to get myself off of the ground. But I didn’t want to make you wait until we got done with the client to see if you had set up your services correctly. So we are using the client here. This part of the series is pretty long as it is.

Finally in the config is the behavior section. In the serviceBehaviors tag we have additional information for our service. You can cut and paste here too making sure that you have your service name correct.

Next, please check to see if your default web site has a net.tcp binding type. To check it, click on the default web site and then right click and then click on Edit Bindings. You should see net.tcp for port 808:*. If you don’t, click on the add button and add it. Later on in this post, we go into setting up bindings on IIS7 on Windows Server 2008. Anyway, when you setup IIS7 on your workstation, all bindings should have been created by default.

Ok, we are getting really close to fireing up our service. We just have to get the address of our service to feed to the WCF Test Client and then we are good to go. Here is how to do that. In IIS7, click on the website that is hosting your services and then in the center pane at the bottom click on Content View. Then find the svc file for your service, click on it and then click on browse. You should get something in your browser like the figure below.

If you got this, you are really in good shape, that means your site is setup correctly and you do not have any gross errors in your config file. What you want is the address up close to the top right after svcutil.exe. Copy and then pull up the WCF Test Client at C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\WcfTestClient.exe. When you get it up, click on File and then Add Service. Past the address into the end point address edit box like the figure below.

Then click on OK and after a bit you should see a dialog box appear with a progress bar saying “Adding”. When finished you should see your service under My Service Projects along with the service method. In the figure below, you can see my ListAll() method. I clicked on the listAll() method and then got a ListAll panel on the right. Then I clicked on the Start a new proxy checkbox near the Invoke button and then clicked on the Invoke button and got the result below (click through the security warning).

The results are the return of the BrandList object from the ListAll() service. If you click on the XML tab on the bottom, you can see the Request and Response messages. If you got this far, you are in really good shape. If not, please post your questions and I’ll answer them asap.

The next part of this post explains how to create an application server using IIS7 and the net.tcp protocol in your enterprise.

Every enterprise has its own security requirements and what configuration is necessary to meet those requirements. So, this article is not intended to be then end all and be all of security, however, for traffic within your LAN, it is my opinion that what we are talking about here will be reasonably secure.

Also, as pointed out earlier in this series, we’re not going into all the options available, but are pointing out one simple and practical approach. Resources for a more detailed discussion of options are here.

Ok, now on to the client. WCF services can either self host, or use IIS. We are going to look at how to host WCF Services with IIS7. We are also going to be using the net.tcp protocol to do it. The reason to use net.tcp is that by doing so you can expose your services equally to a web site or to a windows forms application. You can do it using http or https, but net.tcp is much faster, and although it is a little harder to configure, it is really worth it.

What we are doing here is to setup the service on its own machine and with its own domain. First thing is to create the DNS domain internally. The default domain on our network is joyousliving.com and we also use maltercorp.com equally. The Windows domain name is joyousliving.com. We also have a number of other domains as we host and do development for clients. We created a new domain called maltercorplabs.com and are using it for hosting services. However the windows forms desktop client is on the joyousliving.com domain. Below is a screenshot of the maltercorplabs.com domain after it was configured with the cheeselistiishostedservices A record.

The next step is to create the site on IIS7 that will do the hosting. To that, first you have to add the IP address you want to use for the site into your NIC configuration. I never use the default web site, and always add additional IP’s for each website I need. The screen shot below shows the configuration of the NIC.

To get there you go to Control Panel / Network Connections and click on the NIC you want to configure. Then click on the properties button and then on the Internet Protocol Version 4 item. Then click on the advanced button and on the top of the dialog box, you’ll see IP addresses. Add the IP there. Aftering adding the IP, make sure you can ping it from your workstation using the fully qualified domain name you setup in the DNS Manager. In this case it is CheeseListIISHostingServices.MaltercorpLabs.com.

Next, create the actual site. My convention is to create a site name that is the same as the A record I created. Under binding make sure you pick the new IP Address you created and leave the rest to default values. We are going to go back and change a few things.

After creating the website, create an application pool where the Managed Pibeline Mode is Integrated. Now comes the fun and controversial part. I change the identity in the Process Model section from the NetworkService to something else. That identity is a regular windows login for each application. Users don’t know anything about it, it’s purpose is to be an administrative or application service account. This account is used as the identity of the website as well as the login to the database. We use an SSPI login to talk to the database so we don’t have to embed a login id and password into the web.config.

So, lets talk about this for a bit. What I want to do as an architect is balance security with maintenance and prevent deployment errors. So, I have at least three and sometimes 4 environments. Each environment will have a complete set of machines; database, web and or services.

Development
Integrated Unit Test
QA
Production

For each application in each environment, I will create a windows login. In each database I create a database role and then assign the application service account to that role. Each environment has the same database role, but each environment will have a different application service account. This makes it very easy to migrate database changes between environments; from dev to IUT to QA and then to production. I don’t have to make any manual changes to any script because I am granting permissions on the role in the database.

Then in any web environment where I am using SSPI logins, the identity in the application pool is what is used to login into SQL Server. Sometimes when moving scripts around, it is possible and likely that you will at one time or another, you will point to a database in the wrong environment. However having a different application service account for each environment will cause an exception to be thrown and you’ll know immediately that the name of the server is wrong.

The reason you need to care about the database login for the service is that we are wrapping an existing website’s dll’s and they need a way to login to the database. You could if you wanted create a different application service account to be used by services from the one used by the website. It does not matter as long as that user gets added to the appropriate database role in the right database and it is the same as the identity in the application pool.

It may seem like a lot of work to create so many users and to do this extra configuration, but you will be glad you did the moment your development process comes under stress. Its much better to see an immediate error telling you that you tried to get into the wrong database, than to realize that you have been pointing to the wrong database and now your data is screwed up, not to say what will happen with your credibility with the users having to re-enter data and trying to remember what they did.

So, right click on the new application pool and then click on advanced settings and change the name of the Identity to your application service account as shown in the image below.

After changing your site’s identity, you need to add a binding to support net.tcp. So, right click on the website that you are going to use to host the service and click on Edit Bindings. Then click on the Add button, and like the image below shows, select net.tcp from the dropdown and enter a port number followed by an asterick. I choose 808:*. then click ok.

Now the website is setup with its own application pool and custom binding and is ready to be published to. So, lets put our programmer’s hat back on and open Visual Studio. We want to change the base address and point to the website we just set up, so change it from localhost. In my case the new address is net.tcp://CheeseListIISHostedServices.MaltercorpLabs.com/. Once you are done with the configuration changes, then go ahead and publish to your new server. You can test it just like you did when you were getting services to run for the first time on your local machine.

Ok, that is it for this part. There was a lot here, and I know this piece stayed pretty high level. Remember there are WCF Learning Resources here on the Computer Mutt. Also, if you have any questions, post them and I’ll answer them ASAP. Next up we will create a web and windows forms client. After that we will dive into transactions and then to exception handling.

A Practical Architecture for WCF - Part 1

Mike Malter — Thu, 20 Aug 2009 20:39:22 +0000

This is the first in a series of articles designed to provide an example of a practical architecture for WCF in its support of a services oriented architecture.

We are going to look at how you could take an existing web site and wrap its functionality in services to be consumed by either a web site or a windows forms application. We will show you how to configure your network and servers to offer these services across domains and machine boundaries. We’ll also take a look at how to structure data contracts to provide robust objects and lists of objects across the wire with exception reporting. Finally we’ll look at how to configure support for distributed transactions and some suggestions for structuring projects to make testing and deployment easier.

There are a few references that I recommend using as you are learning WCF and they are posted here on the Computer Mutt. Those resources will address a wider range of WCF concepts much more in-depth than I will here as this article is focused on providing an approach to a particular problem, and not structured to review all options that are available. Michelle Leroux’s introduction in the chapter on working with WCF in Visual Studio 2008 which covers SOA and WCF is total gold, and every time I re-read it I get something out of it.

Ok, let’s take the first step look at what we have and what we want to wind up with. We are starting out with a current web site that site is a very simple ASP.NET 3.5 public web application in production that provides a list of cheese brands and cheese types that are made without animal rennet. It has discreet layers consisting of a data layer, business layer and presentation layer in the form of web pages. The data layer talks to Microsoft SQL Server 2008 and runs on IIS7 on Windows Server 2008. Everything is 64 bit and everything is on a single box. Basically it is simple running website and thus a good candidate for a first step.

Here is a network diagram showing the current architecture of the website we are going to transform:

The diagram below is what the architecture will look like after we transform it. The differences are that major components are separated by machine boundaries. The database has its own box, services has its own box, and the web site has its own box. On the services box we also have the original business and data layers along with IIS.

Once we transform our original website and began offering services, we are simply serving content to presentation layers both inside and outside of your network allowing you to use either browsers or Windows Forms applications. In the case of a browser, the user points to a URL to get content, in your Windows Forms application, you can configure an endpoint to point to, either way, desktop configuration and support can be much simpler as a result.

Configuring the environment for services behind the firewall is simpler than offering them over the network, and the scope of this series is for services on the inside of the firewall. In a subsequent article, I’ll walk you through the steps necessary to offer secure services over the internet.

We are going to use Visual Studio 2008 with .NET 3.5 along with WCF Services Templates to code services. Development is on a Vista machine. An aside on Vista first. I’ve heard how Vista sucked and to avoid it, however when I switched to developing and supporting ASP.NET apps on Windows Server 2008 & IIS7, I found that using Vista simplified development.

First, Vista uses IIS7 (which is the version on Server 2008) and it understands the web.config files generated by Visual Studio 2008. I can also configure those web.config files once in one place in the file, unlike developing on XP where you have to configure the same thing in several places in the file. Yes, UAC blows, but you can turn it off and I have had no problems using it. I’m not advocating that you switch from XP if you want to develop services to run on Windows Server 2008, I’m just passing along that I found with Vista I created a less error prone development environment.

One last word on environment. While you will be able to do everything in this series of articles on one machine, it will work out better for you in the long run if you have an Active Directory environment with at least three dedicated boxes; Web, Services, Database. If you have limited equipment, consider creating seperate environments using Hyper-V. Go to my recent post for help on creating and cloning Hyper-V environments.

I really want to emphasize that it is in your interest to invest the sweat in creating seperate environments to run the examples in this series. The reason is that a lot happens by default when you run everything on a single box and you’ll never realize it until you begin to move things around, and by then you’ll have to spend an undetermined amount of time to backtrack to uncover your mistakes. Also, nobody is really going to be running this stuff on a single machine in a production environment anyway, so you might as well get used to it right off of the bat. If you understand what the network requires to support WCF you’ll be more valuable to your company and customers.

Before finishing this introduction, some thoughts on the Web Client Software Factory (WCSF). This tool will allow you to code WCF services using a visual designer in Visual Studio. One of its strengths is that it forces a particular format on project directory structure which can be advantagous since everyone on the team will be forced to structure their work the same way. I began working in WCF using this tool, and I have to say it was a very confusing time for me as took a lot of effort to understand where the tool left off and WCF began; it was unnecessairly complex.

Furtheremore, once you start a project in the tool and need to make changes, you must go back and make them through the designer. There are some other very severe side effects to. One is that the tool will create directory and filenames that will break Visual Studio and this goes double if you are using Team Foundation Server. Having outlined some of my concerns, you have to that creating such a tool is a huge accomplishment, and although this tool is just in its beginning stages, over time I am certian refinements will be introduced smoothing out some of its early difficulties.

In my mind it is best to start out simply and do everything manually so you get a clear understanding of what you need to do to support WCF services.

Next up – A Practical Architecture for WCF – Part 2 which will demonstrate the creation of services.

Want Open Search Integration in Your Website…?

ducas — Wed, 05 Aug 2009 22:42:37 +0000

Over the past few weeks, Tatham Oddie, Damian Edwards and myself have been working on publishing a framework/toolkit for integration OpenSearch into any ASP.NET search enabled website. I’m pleased to announce we have finally hit a release!

The project is available at opensearchtoolkit.codeplex.com. Tatham has a great post on how to integrate it into your site on his blog…

OpenSearch is a technology that already has widespread support across the web and is now getting even more relevant with Internet Explorer 8’s Visual Search feature and the Federated Search feature in the upcoming Windows 7 release.

…

Now it’s time to make it even easier. Ducas Francis, one of the other members of my team, took on the job of building out our JSON feed for Firefox as well as our RSS feed for Windows 7 Federated Search. More formats, more fiddly serialization code. Following this, he started the OpenSearch Toolkit; an open source, drop-in toolkit for ASP.NET developers to use when they want to offer OpenSearch.

Today marks our first release.

So get on over to codeplex, hit up Tatham’s blog for instructions and drop the toolkit into your web site so you can take advantage of all the coolness that is OpenSearch.

Using RedGate ANTS to Profile XUnit Tests

David Longnecker — Wed, 05 Aug 2009 16:29:22 +0000

RedGate’s ANTS Performance and Memory profilers can do some pretty slick testing, so why not automate it? The “theory” is that if my coverage is hitting all the high points, I’m profiling all the high points and can see bottlenecks.

So, how does this work? Since the tests are in a compiled library, I can’t just “load” the unit tests. However, you can load Xunit and run the tests.

NOTE: If your profiling x86 libraries on an x64 machine, you’ll need XUnit 1.5 CTP (or later) that includes xunit.console.x86.exe. If you’re on an x86 or do not call x86 libraries, pay no attention to this notice.

To begin, start up ANTS Performance Profiler and Profile a New .NET Executable.

For the .NET Executable, point it towards XUnit and in the Arguments, point it towards the library you are testing. Simple enough.

Click “Start Profiling” and let the profiling begin!

Now if I could just get the “top 10” methods to export to HTML or something so I could automate this in our reporting.

Tags: ANTS+Profiler, RedGate, xunit

CSS Goodies in IE 8

Udaya Kumar — Fri, 31 Jul 2009 05:51:39 +0000

Microsoft has made plenty of changes and additions to IE8 which is fully compliant with the CSS Leve

Fetching Nested Group Memberships in Active Directory

David Longnecker — Wed, 22 Jul 2009 14:47:14 +0000

As we’ve started using Active Directory more and more to provide single sign-on services for our web applications, group memberships have become more important.

We recently rolled out an application that took advantage of nesting groups (easier to add and manage five global groups than 10,000 individuals); however, our existing code to fetch memberships wouldn’t look at nested groups.

So if I was a member of “Student Achievement”, how could I parse the memberships of that group and determine if I was in “MIS”?

Thankfully, a bit of recursion does the trick…

As our infrastructure is entirely Windows Server 2003 and higher, I use the System.DirectoryServices.Protocols namespace and methods to connect to and parse out information from LDAP. Because of this, I rely on SearchResult(s) rather than DirectoryEntries.

In our environment, a “user” is defined as:

“(&(objectCategory=person)(objectClass=user)(mail=*)({0}={1}))”

Everything looks pretty plain except we require that a valid “user” have an email address. That ensures we filter out junk/test accounts as only employees have Exchange accounts.

Groups are even easier:

“(objectCategory=group)”

If, say I’ve queried for a single user, the groups property is populated simply by looking at the local user’s “memberOf” attribute.

private static IEnumerable<string> ParseGroupMemberships(SearchResultEntry result, int countOfGroups)
{
    for (int i = 0; i < countOfGroups; i++)
    {
        var fullGroupName = (string) result.Attributes["memberOf"][i];
        //Fully Qualified Distinguished Name looks like:
        //CN={GroupName},OU={AnOU},DC={domain},DC={suffix}
        //CN=DCI,OU=Groups,OU=Data Center,DC=usd259,DC=net
        int startGroupName = fullGroupName.IndexOf(“=”, 1);
        int endGroupName = fullGroupName.IndexOf(“,”, 1);
        if (startGroupName != -1)
        {
            string friendlyName =
                fullGroupName.Substring(startGroupName + 1, (endGroupName – startGroupName) – 1);
            yield return friendlyName;
        }
    }
}

That was fine for the primary groups (attached through memberOf); however, it didn’t look at the groups those groups were a “memberOf”.

After quite a bit of trial and error, the new method looks pretty ugly, but seems to be quite performant and reliant in tests.

private static IEnumerable<string> ParseGroupMemberships(
    SearchResultEntry result, int countOfGroups)
{
    var primaryGroups = new List<string>(countOfGroups);
    var allGroups = new List<string>();
 
    for (int index = 0; index < countOfGroups; index++)
    {
        primaryGroups.Add(result.Attributes[ldapGroupsAttribute][index].ToString());
        allGroups.Add(result.Attributes[ldapGroupsAttribute][index].ToString());
    }
 
    var connection = new ActiveDirectory().GetConnection();
 
    while (0 < primaryGroups.Count)
    {
        var searchRequest = new SearchRequest(distinguishedName,
                                              CreateFilterFromGroups(primaryGroups),
                                              SearchScope.Subtree,
                                              ldapGroupsAttribute);
        primaryGroups.Clear();
 
        var response = (SearchResponse)connection.SendRequest(searchRequest);
        if (response != null)
        {
            int entriesCount = response.Entries.Count;
            for (int entry = 0; entry < entriesCount; entry++)
            {
                DirectoryAttribute groupList = 
                    response.Entries[entry].Attributes[ldapGroupsAttribute];
 
                if (groupList != null)
                {
                    int groupCount = groupList.Count;
                    for (int index = 0; index < groupCount; index++)
                    {
                        string dn = groupList[index].ToString();
                        if (!allGroups.Contains(dn))
                        {
                            allGroups.Add(dn);
                            primaryGroups.Add(dn);
                        }
                    }
                }
            }
        }
    }
    connection.Dispose();
 
    foreach (string dn in allGroups)
    {
        yield return GetFriendlyName(dn);
    }
}

Here’s a breakdown of the highlights:

var primaryGroups = new List<string>(countOfGroups);
var allGroups = new List<string>();
 
for (int index = 0; index < countOfGroups; index++)
{
    primaryGroups.Add(result.Attributes[ldapGroupsAttribute][index].ToString());
    allGroups.Add(result.Attributes[ldapGroupsAttribute][index].ToString());
}

This section takes the SearchResultEntry’s primary groups and adds each one of them to two lists.

The ‘primaryGroups’ list is exactly that—here’s a list of groups that we need to iterate over and find the nested groups.
The ‘allGroups’ will hold our master list of every unique group and will provide our return value.

var searchRequest = new SearchRequest(distinguishedName,

CreateFilterFromGroups(primaryGroups),

SearchScope.Subtree,

ldapGroupsAttribute);

primaryGroups.Clear();

This code formulates our LDAP search request. distinguishedName and ldapGroupsAttribute are two constants in my code base (for our domain’s DN and “memberOf”). CreateFilterFromGroups takes the list of groups and concats them together—so we’re only looking at the groups we want, not everything.

Finally, we’re reusing our primaryGroups list to look for nested within nested… within nested, so clear that out—infinite loops hinder performance.

int entriesCount = response.Entries.Count;
for (int entry = 0; entry < entriesCount; entry++)
{
    DirectoryAttribute groupList = 
        response.Entries[entry].Attributes[ldapGroupsAttribute];
 
    if (groupList != null)
    {
        int groupCount = groupList.Count;
        for (int index = 0; index < groupCount; index++)
        {
            string dn = groupList[index].ToString();
            if (!allGroups.Contains(dn))
            {
                allGroups.Add(dn);
                primaryGroups.Add(dn);
            }
        }
    }
}

Here’s our massive, disgusting block of if statements that populate the lists and keep the where statement running as long as primaryGroups returns a count > 0.

foreach (string dn in allGroups)
{
    yield return GetFriendlyName(dn);
}

Finally, use a helper method to convert the DN to a “friendly name” and return it to the caller (using yield since our method returns an IEnumerable<string>).

Running a quick test gives me:

UserAccount_Can_Get_Group_Memberships_With_Default_Security : Passed

Group count for David Longnecker is 138
Elapsed time for first query: 00:00:00.0420000

Wow, I’m in a lot of groups… O_o. The query is relatively quick (that is with connection buildup and teardown time and generating the rest of the attributes of the user) especially considering our AD infrastructure is far from optimal.

In addition, a LDAP query using ADUC gives the same results.

If nothing else, its consistent!

Tags: c#, .net+3.5, active+directory, group+membership

Filtering an Enum by Attribute

David Longnecker — Thu, 09 Jul 2009 16:59:08 +0000

I had a curve ball thrown at me this morning—changing requirements. It happens and was easily solved by a couple of custom attributes and a helper method.

UPDATE: I’ve updated the code (and explaination) for FilterEnumWithAttributeOf below to tidy it up a bit.

In our current project, there is an enum of standard, static “periods” (times of days students are in school). Easy enough.

BeforeSchool = 0,
FirstPeriod = 1,
SecondPeriod = 2,
etc.

But what happens if we want to “query” our list down a bit… say a certain group only wanted a subset of the “periods”.

I could create an entirely different Enum — Group1Period and Group2Period.

But then handling things in FluentNHibernate’s automapping would get freaked out with the Period property.

So, what about a custom attribute?

I can assign multiple custom attributes to the same Enum field so I can be in Group1 and Group2 at the same time.
I can keep the same Enum “Period” for my ORM layer.
Now how do I query it down…?

Here’s an abstracted example of how the enum looks right now:

public enum Period
{
    [Elementary][Secondary]
    [Description("Before School")]
    BeforeSchool = 0,
 
    [Elementary]
    Homeroom = 12,
 
    [Secondary]
    [Description("1st")]
    First = 1,
}

Elementary and Secondary (our two groups, in this case) are “logicless” attributes (I’m just looking at them as flags, not passing/storing information).

[AttributeUsage(AttributeTargets.Field)]
public class ElementaryAttribute : Attribute
{
}
 
[AttributeUsage(AttributeTargets.Field)]
public class SecondaryAttribute : Attribute
{
}

Now, to filter out those pesky periods based on the attributes.

Update:

Old Code!

public IEnumerable<TEnum> FilterEnumWithAttributeOf<TEnum, TAttribute>()
{
    foreach (var field in
        typeof (TEnum).GetFields(BindingFlags.GetField |
                                 BindingFlags.Public |
                                 BindingFlags.Static))
    {
        foreach (var attribute in 
            field.GetCustomAttributes(typeof (TAttribute), false))
        {
            yield return (TEnum) field.GetValue(null);
        }
    }
}

New Code!

public static IEnumerable<TEnum> FilterEnumWithAttributeOf<TEnum, TAttribute>()
    where TEnum : struct
    where TAttribute : class
{
    foreach (var field in
        typeof(TEnum).GetFields(BindingFlags.GetField |
                                 BindingFlags.Public |
                                 BindingFlags.Static))
    {
 
        if (field.GetCustomAttributes(typeof(TAttribute), false).Length > 0)
            yield return (TEnum)field.GetValue(null);
    }
} 

Why new code?

Well, after looking over the code, I don’t need to iterate through each attribute, simply see if the field contains it (Length > 0). If it does, then return it. That cuts a loop out of our code and performs the same function. I also added two generic constraints. You can’t constrain by Enum, but struct works well.

I’m passing in two generics in this case—TEnum, which is the type of the of the Enum and TAttribute.. the type of the attribute. Yeah, I realize that my creativity of naming is pretty low. Work with me here, alright?

Past that, the loops are pretty easy.

Loop through each field of the enumeration. Return the field (GetField) and be sure to check Public and Static fields.
Loop through each custom attribute on each field (returned by GetField) and only return the fields that match the type of our attribute. I pass along the false parameter (do not inherit) because I’m not interested in inherited attributes. You could leave this as true. YMMV.
If the field’s attribute’s contains our type, yield out the actual Enum value (a string of the field isn’t as useful).

Now, for using it…

var enums = FilterEnumWithAttributeOf<Period, ElementaryAttribute>();
 
foreach (var period in enums)
{
    Console.WriteLine(“{0}, {1}”.AsFormatFor(period, (int)period));
}

Easy enough. ElementaryAttribute returns:

BeforeSchool, 0
Homeroom, 12
AfterSchool, 10
etc..

Running the same code, but asking for SecondaryAttribute returns:

BeforeSchool, 0
First, 1
Second, 2
etc..

Sweet.

Tags: enum, c#, generics

AutoMappings in NHibernate - A Quick Runthrough

David Longnecker — Fri, 26 Jun 2009 19:58:00 +0000

For most of my projects, at least since I’ve moved to NHibernate/Fluent NHibernate, I’ve been trapped using the existing data structures of prior iterations. Funky naming conventions (many due to cross-cultural, international column naming), missing data relationships, and general craziness.

Having used Fluent Mappings (creating a class that implements ClassMap<objectType>) in the past, they were a huge jump up from writing painful data objects, connecting them together, and recreating the wheel with “SELECT {column} from {table}” code. Create a map, use the fluent methods to match column to property, and away you go.

In a recent project, I’ve had the opportunity to build a new system from the ground up. With this, I decided to dive head first into using the AutoMappings functionality of Fluent NHibernate.

This post is somewhat a rambling self-discussion of my explorations with AutoMappings.

What are AutoMappings?

The FluentNHibernate wiki provides a simple definition:

[…] which is a mechanism for automatically mapping all your entities based on a set of conventions.

Rather than hand-mapping each column to a property, we create conventions (rules) to map those.. automatically. Hey look, auto…mappings.

How?

Using the same fluent language, configuring AutoMapping is an exercise in implementing conventions for the logical naming and handling of data.

Fluently
    .Configure()
    .Database(MsSqlConfiguration.MsSql2005
                  .ConnectionString(cs => cs
                                              .Server(“server”)
                                              .Database(“db”)
                                              .Username(“user”)
                                              .Password(“password”)
                  )
                  .UseReflectionOptimizer()
                  .UseOuterJoin()
                  .AdoNetBatchSize(10)
                  .DefaultSchema(“dbo”)
                  .ShowSql()
    )
    .ExposeConfiguration(raw =>
                             {
                                 // Testing/NHibernate Profiler stuffs.
                                 raw.SetProperty(“generate_statistics”, “true”);
                                 RebuildSchema(raw);
                             })
    .Mappings(m =>
              m.AutoMappings.Add(AutoPersistenceModel
                                     .MapEntitiesFromAssemblyOf<Walkthrough>()
                                     .ConventionDiscovery.Setup(c =>
                                                                    {
                                                                        c.Add<EnumMappingConvention>();
                                                                        c.Add<ReferencesConvention>();
                                                                        c.Add<HasManyConvention>();
                                                                        c.Add<ClassMappingConvention>();
                                                                    })
                                     .WithSetup(c => c.IsBaseType = type => type == typeof (Entity)))
                  .ExportTo(@”.\”)
    );

As you can see above, the only difference from a fluent mappings configuration is in the actual Mappings area. Good deal! That helps ensure my existing work using fluent mappings could translate without too much headache.

I’ve specified four conventions. Each of these conventions have interfaces that provide the necessary methods to ensure your rules are appied to the correct objects.

EnumMappingConvention

internal class EnumMappingConvention : IUserTypeConvention
{
    public bool Accept(IProperty target)
    {
        return target.PropertyType.IsEnum;
    }
 
    public void Apply(IProperty target)
    {
        target.CustomTypeIs(target.PropertyType);
    }
 
    public bool Accept(Type type)
    {
        return type.IsEnum;
    }
}

The great thing about these methods is they’re fluent enough to translate to English.

Accept… targets where the property type is an enumeration.

Apply… to the target that the “Custom Type Is” the property type of the target.
NOTE: This translates from a ClassMap into: Map(x => x.MyEnumFlag).CustomTypeIs(typeof(MyEnum));

Accept… a type that is an enumeration.

ReferenceConvention

The Reference convention handles those reference relationships between our classes (and the foreign keys).

internal class ReferencesConvention : IReferenceConvention
{
    public bool Accept(IManyToOnePart target)
    {
        return string.IsNullOrEmpty(target.GetColumnName());
    }
 
    public void Apply(IManyToOnePart target)
    {
        target.ColumnName(target.Property.Name + “Id”);
    }
}

The most important part here is enforcing how your foreign keys are going to be named. I prefer the simple {Object}Id format.

Car.Battery on the object side and [Car].[BatteryId] on the database side.

HasManyConvention

The HasManys are our lists, bags, and collections of objects.

internal class HasManyConvention : IHasManyConvention
{
 
    public bool Accept(IOneToManyPart target)
    {
        return target.KeyColumnNames.List().Count == 0;
    }
 
    public void Apply(IOneToManyPart target)
    {
        target.KeyColumnNames.Add(target.EntityType.Name + “Id”);
        target.Cascade.AllDeleteOrphan();
        target.Inverse();
    }
}

We want to make sure that we haven’t added any other key columns (the Count == 0), and then apply both the naming convention as well as a few properties.

Cascade.AllDeleteOrphan() and Inverse() allows our parent objects (Car) to add new child objects (Car.Battery (Battery), Car.Accessories (IList<Accessory>)) without separating them out.

ClassMappingConvention

Finally, the important Class mapping. This convention ensures that our tables are named property with pluralization.

public class ClassMappingConvention : IClassConvention
{
    public bool Accept(IClassMap target)
    {
        return true; // everything
    }
 
    public void Apply(IClassMap target)
    {
        target.WithTable(PluralOf(target.EntityType.Name));
    }
}

I’m using a pluralization method from one of my base libraries that I borrowed from Hudson Akridge. This helper method works really well and I don’t need to add additional references and libraries into my application just to handle the table names.

public static string PluralOf(string text)
  {
      var pluralString = text;
      var lastCharacter = pluralString.Substring(pluralString.Length – 1).ToLower();
 
      // y’s become ies (such as Category to Categories)
      if (string.Equals(lastCharacter, “y”, StringComparison.InvariantCultureIgnoreCase))
      {
          pluralString = pluralString.Remove(pluralString.Length – 1);
          pluralString += “ie”;
      }
 
      // ch’s become ches (such as Pirch to Pirches)
      if (string.Equals(pluralString.Substring(pluralString.Length – 2), “ch”,
                        StringComparison.InvariantCultureIgnoreCase))
      {
          pluralString += “e”;
      }
      switch (lastCharacter)
      {
          case “s”:
              return pluralString + “es”;
          default:
              return pluralString + “s”;
      }
  }

Save and build. The ExportSchema method will generate the SQL and/or regen the database based on the specifications you’ve provided to it. and you’re ready to hit the ground running!

Tags: fluent+nhibernate, automapping, nhibernate, sql+server+2005, .net+3.5, c#

Rendering the Web Equally on Mobile Devices

David Longnecker — Fri, 26 Jun 2009 15:57:00 +0000

I’ve been digging through the Interwebs for a while now and, I thought, had worked out all of the “kinks” of rendering on a mobile device—specifically iPhones.

The special ‘viewport’ meta tag means the world to iDevices.

meta name=“viewport” content=“width = device-width” />

I’m faced with a new challenge—the Palm Pre’s built-in web browser. My shiny new phone is great, but it isn’t without glitches.

The first glitch I’ve found appears to be a DNS issue— http://myserver/web won’t resolve; however, http://123.45.67.89/web will. It seems to be touchy. Most of our webs work just fine, others don’t. I haven’t narrowed it down to a single server or architecture as it seems to be a bit of everything. Wonky.

The next glitch is more important—the rendering. One of our tools is a simple form-based tool that looks great on the iPhone; however, renders partial screen and “garbles” when you move around the screen.

Palm Pre:

iTouch/iPhone:

I’ve also found that anything in an ASP.NET Update Panel (like those Select buttons) are unusable. Other webs I’ve used (Bank of America, etc) use AJAX just fine, so I don’t think it’s that—probably a coding issue I need to dig into and resolve.

UPDATE: Explicitly adding “LoadScriptsBeforeUI=’true’” to the ASP.NET ScriptManager seems to help with this.. a little.

Anyone else worked specifically with the Pre devices and rendering? I’d appreciate any meta tags or layout ideas that worked. The Pre isn’t a common device in our organization—yet.

Tags: Palm+Pre, iPhone, asp.net, ajax, mobile+web

Microsoft Windows SDK for Windows 7 and .NET Framework 3.5 SP1: RC (ISO)

esersahin — Sat, 20 Jun 2009 19:48:39 +0000

http://www.microsoft.com/downloads/details.aspx?FamilyID=6db1f17f-5f1e-4e54-a331-c32285cdde0c&displaylang=en

Кодогенерация T4

der Igel — Sat, 13 Jun 2009 17:56:00 +0000

Нет, это не про Терминатора

Это про использование T4 Text Template Transformation Toolkit, встроенного в Visual Studio 2008 для автоматической генерации кода.

Кратко задача – есть исходники. Опять-то таки сгенерированные, но другим инструментом, Thrift.
Код на C#, публичные поля и свойства в классах с одинаковым именем, только различаются регистром.
Код необходимо использовать из VB.NET. Упс! VB.NET нечувствителен к регистру! Приплыли.

Исходники конечно есть, но они регулярно обновляются – так что их исправлять нельзя.
Классы не помечены partial – расширить напрямую тоже нельзя.

Но у нас же есть extension методы – спасибо .NET 3.5! Можно понаписать методов (эх… пока только методы, эктеншен свойств нет) с названием совпадающим со свойствами, но с каким-нибудь префиксом, подчеркиванием например.

Ок, хорошо. Но вручную писать обертки на 20 классов?! Да они еще, как я сказал, могут обновиться в будущем. Тут нужна автоматизация… И в VS 2008 она уже встроена – движок кодогенерации T4.

Файлы с расширением tt. Синтаксис очень похож на ASP.NET, только исполняются внутри Visual Studio (и не только, хостом может выступать любое приложение, и ваше в том числе).

И вот всё волшебство:

<#@ template language=“C#v3.5″ hostspecific=“true” #>

<#@ assembly name=“EDAM.dll” #>

<#@ assembly name=“System.Core” #>

<#@ import namespace=“System.CodeDom” #>

<#@ import namespace=“System.CodeDom.Compiler” #>

<#@ import namespace=“System.IO” #>

<#@ import namespace=“System.Linq” #>

<#@ import namespace=“System.Reflection” #>

<#@ import namespace=“Evernote.EDAM.Type” #>

// Autogenerated by <#= Host.GetType() #>

// <#= DateTime.Now #>

// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING

namespace Evernote.EDAM.Type

{

<# foreach (var @class in Assembly.GetAssembly(BaseClass)

              .GetExportedTypes()

              .Where(type => !type.IsNested)

              .Where(type => type.Namespace == BaseClass.Namespace)) { #>

  public static class <#= @class.Name #>Ex

  {

  <# foreach (var prop in @class.GetProperties()) { #>

    public static <#= PrintType(prop.PropertyType) #> _<#= prop.Name #>(this <#= prop.DeclaringType #> value)

    {

      return value.<#= prop.Name #>;

    }

  <# }#>

  }

<# } #>

}

<#+ Type BaseClass = typeof(Note); #>

<#+ 

public string PrintType(Type type)

{

  var typeExpr = new CodeTypeReferenceExpression(type);

  var csProvider = Microsoft.CSharp.CSharpCodeProvider.CreateProvider(“C#”);

  var writer = new StringWriter();

  csProvider.GenerateCodeFromExpression(typeExpr, writer, new CodeGeneratorOptions());

  return writer.ToString();

} #>

Вкратце, по шагам:

Перебираем все классы из сборки, из нужного пространства имен.
Для каждого класса генерируем статический класс с таким-же именем и суффиксом Ex.
Перебираем все свойства класса.
Генерируем экстеншен-метод нужного типа с именем как оригинальное ствойство, но с префиксом _.
Для генерация имени нужного типа используется маленькая хитрость. Так как по простому дженерики будут выводиться в IL-нотации, т.е. например System.Generic.List’1[System.String]. И это не будет компилироваться. Надо System.Generic.List<System.String> (для C#). Что и делается через CodeDom. Так как сборка на C# – то и провайдер для C# используется. Можно генерировать и в VB. Как в CodeDom, так и в самом T4 кстати.

Всё, теперь при сборке будет генерироваться набор расширений для каждого нужного класса с методами дублирующими все свойства, которые уже без проблем можно использовать в VB.NET. Кстати, в VB можно опускать скобки при вызове метода, если он не принимает параметров, что делает код еще более изящным (насколько вообще можно говорить об изящности в этой ситуации):

C# note.Attributes.Lattitude

VB.NET note._Attributes._Lattitude

Полезные ссылки:

T4: Text Template Transformation Toolkit
Generating Artifacts By Using Text Templates (раздел в MSDN)
Visual T4 (плагин для редактирования файлов tt с подсветкой)

Benchmarks : Comparing LINQ to NHibernate Transforms/Grouping

David Longnecker — Fri, 12 Jun 2009 14:07:37 +0000

Yesterday, I wrote about setting up NHibernate to query up, group, count, and transform results and return them into a control. Why did I go to such effort? Well, the original LINQ query I had that refined the results didn’t perform up to par. As some may note, premature optimization is never a good practice so I needed some stats to back up the claims.

Overnight, I wrote up a quick test to query up both ways and benchmark the results. Here’s what I found.

The “test”:

public void TEMP_quick_compare_of_linq_to_nhibernate()
{
    var schoolId = 120;
 
    var benchmark = new Benchmark();
    using (var repository = new IncidentRepository())
    {
        benchmark.Start();
        var resultsFromLinq = 
            repository.GetCountByIncidentCodeWithLinq(schoolId);
        foreach (var item in resultsFromLinq) 
        {
            Console.WriteLine(item);
        }
        benchmark.Stop();
        Console.WriteLine(“Linq: {0}”.AsFormatFor(benchmark.ElapsedTime));
 
        benchmark.Start();
        var resultsFromNhibernate = 
            repository.GetCountByIncidentCode(schoolId);
        foreach (var item in resultsFromNhibernate)
        {
            Console.WriteLine(item);
        }
        benchmark.Stop();
        Console.WriteLine(“NHibernate: {0}”.AsFormatFor(benchmark.ElapsedTime));
    }
}

Setting up the benchmark (and the NHibernate Init) are outside of the benchmark—they’re necessary overhead. I’m also iterating through each of the results as part of the benchmark to ensure that everything is evaluated. Past that, pretty basic. On the database side, I’ve disabled statement caching to not sway the results as much.

With 24 records (the test data in the system), the results were pretty clear. The average of running the benchmark 100 times resulted in…

Linq: 00:00:00.7050000
NHibernate: 00:00:00.0190000

With 24 records, NHibernate was about 37x faster.

That’s nice, but what happens in a few weeks when there are a few thousand records? I populated a few hundred of each incident type into the system, giving me almost 4000 records (the anticipated monthly load of the system by the customer). How’d that change our averages?

Linq: 00:00:00.8869746
NHibernate: 00:00:00.1381518

Now we’re only 6x faster with NHibernate vs. LINQ. The duration from 24 to 4000 records for LINQ jumped ~.18 seconds for a 25% gain where as NHibernate jumped ~.11 seconds for a 626% gain.

So, with that, my original gut feeling and assumptions were wrong. More and more records don’t really slow down the LINQ filtering.. at least not by much. The performance gain is still appparent between the two methods (.88 sec vs. .13 sec); however, how much of that time is eaten up by rendering, server latency, etc and not by the actual processing?

Tags: nhibernate, linq, performance, c#, asp.net, optimization