Managing Multiple Configuration File For Different Application Life cycles In .Net Applications

by Vahid 25. May 2009 16:50

All of us have already dealt with the problem of promoting configuration files in different application life cycles. this problem can be as simple as managing different connection strings for different databases in each environment to managing the other complicated settings in each environment.

so many times it happens that we forget to update the configuration file (web.config or app.config) before promotes. what we had already done was to keep one configuration file for each environment (development, testing, staging …) and after promote before build overwrite the the existing configuration file. but even in this case we used to miss to update the configuration file with the latest information. anyway i came across the very good solution in Scott Hanselman's blog. ok here is the solution.

  1. In your project Click the configuration management dropdown and select "Configuration Manager."image

You'll probably have Debug and Release configurations, but you can also make custom ones and base them on existing configuration. In this dialog I've made a new "Deploy" and I'll base it on the "Release" configuration.

WindowClipping (8)

Make sure to create a Solution Configuration AND a Project Configuration, as they are different. Here I've made one called Deploy for the Project also. If you get an error message, be aware of the "Create new project configurations" checkbox. You might get a warning if you are making a new configuration and the dialog tries to make another configuration with the same name; uncheck the checkbox if that happens. Of course, you can have as many Configurations as you'd like.

deploy

2. Add some custom configuration stuff in web.config, like connectionStrings:

	   1: <connectionStrings>
	
	   2:     <add name="Foo"
	
	   3:          connectionString="Data Source=localhost;Initial Catalog=DatabaseName;
	
	   4:                            User Id=sa;Password=debug;"
	
	   5:          providerName="System.Data.SqlClient" />
	
	   6: </connectionStrings>
	

See now I've made the password in my nonsense connectionString = "debug"? Now, create three new web.config's by CTRL-dragging the web.config on top of the project. Name them web.config.debug, web.config.deploy, and web.config.release. Make the password equal to "deploy" and "release" respectively.

WindowClipping (10)

3. Ok,  now we've got different configuration and different configuration files. Let's create a batch file called "copyifnewer.bat" and here's the contents:

	   1: @echo off
	
	   2: echo Comparing two files: %1 with %2
	
	   3:  
	
	   4: if not exist %1 goto File1NotFound
	
	   5: if not exist %2 goto File2NotFound
	
	   6:  
	
	   7: fc %1 %2 
	
	   8: if %ERRORLEVEL%==0 GOTO NoCopy
	
	   9:  
	
	  10: echo Files are not the same.  Copying %1 over %2
	
	  11: copy %1 %2 /y & goto END
	
	  12:  
	
	  13: :NoCopy
	
	  14: echo Files are the same.  Did nothing
	
	  15: goto END
	
	  16:  
	
	  17: :File1NotFound
	
	  18: echo %1 not found.
	
	  19: goto END
	
	  20:  
	
	  21: :File2NotFound
	
	  22: copy %1 %2 /y
	
	  23: goto END
	
	  24:  
	
	  25: :END
	
	  26: echo Done.
	

Basically this batch file will copy a file over another if the files don't match. It's not strictly "copyifnewer" (like, not at all) but it does the job.

Why bother with a batch file to check for changes and not just copy over the file every time? Well, each time you copy over a web.config it restarts all the designers and running AppDomains that are watching that file. No need to copy over a file if it hasn't changed...everything will churn less.

Put this copyifnewer.bat file in the root of your project.

WindowClipping (10)

4. Create a Pre-build Event. Right-click on your Project and select Properties. Click Build Events and in the "Pre-build event command line" and enter this value:

	"$(ProjectDir)copyifnewer.bat" "$(ProjectDir)web.config.$(ConfigurationName)" "$(ProjectDir)web.config"
	

Notice the magic dust, the $(ConfigurationName) project variable, that contains "Debug" or "Release" or "Deploy."

WindowClipping (9)

5. Build. Now if you build, you'll see in the Build Output the batch file being run and the files being copied. Because it's a Pre-Build Event it'll be seen in both the Build Output in Visual Studio .NET.

When you build within Visual Studio the currently selected item in the drop-down list is the current configuration.  now you have different configuration file for each build

there is catch here and that is we have to remember that we've got to keep web.config's in sync if there's lots of settings, but we could totally break it apart via "include files."

Tags: , ,

.Net | Technical

Differences between XML and JSON

by Vahid 24. May 2009 05:29

Here are some key differences between JavaScript Object Notation (or JSON), an open and text-based data exchange format, that provides a standardized data exchange format better suited for Ajax-style web applications and XML.

Although Both JSON and XML can be used to represent native, in-memory objects in a text-based, human-readable, data exchange format, but the two data exchange formats are isomorphic—given text in one format, an equivalent one is conceivable in the other.

following tables is a high level comparision between JSON and XML.

Key Characteristic Differences between XML and JSON

CharacteristicXMLJSON
Data types Does not provide any notion of data types. One must rely on XML Schema for adding type information. Provides scalar data types and the ability to express structured data through arrays and objects.
Support for arrays Arrays have to be expressed by conventions, for example through the use of an outer placeholder element that models the arrays contents as inner elements. Typically, the outer element uses the plural form of the name used for inner elements. Native array support.
Support for objects Objects have to be expressed by conventions, often through a mixed use of attributes and elements. Native object support.
Null support Requires use of xsi:nil on elements in an XML instance document plus an import of the corresponding namespace. Natively recognizes the null value.
Comments Native support and usually available through APIs. Not supported.
Namespaces Supports namespaces, which eliminates the risk of name collisions when combining documents. Namespaces also allow existing XML-based standards to be safely extended. No concept of namespaces. Naming collisions are usually avoided by nesting objects or using a prefix in an object member name (the former is preferred in practice).
Formatting decisions Complex. Requires a greater effort to decide how to map application types to XML elements and attributes. Can create heated debates whether an element-centric or attribute-centric approach is better. Simple. Provides a much more direct mapping for application data. The only exception may be the absence of date/time literal.
Size Documents tend to be lengthy in size, especially when an element-centric approach to formatting is used. Syntax is very terse and yields formatted text where most of the space is consumed (rightly so) by the represented data.
Parsing in JavaScript Requires an XML DOM implementation and additional application code to map text back into JavaScript objects. No additional application code required to parse text; can use JavaScript's eval function.
Learning curve Generally tends to require use of several technologies in concert: XPath, XML Schema, XSLT, XML Namespaces, the DOM, and so on. Very simple technology stack that is already familiar to developers with a background in JavaScript or other dynamic programming languages.

JSON is a relatively new data exchange format and does not have the years of adoption or vendor support that XML enjoys today (although JSON is catching up quickly). The following table highlights the current state of affairs in the XML and JSON spaces.

Support Differences between XML and JSON

SupportXMLJSON
Tools Enjoys a mature set of tools widely available from many industry vendors. Rich tool support—such as editors and formatters—is scarce.
Microsoft .NET Framework Very good and mature support since version 1.0 of the .NET Framework. XML support is available as part of the Base Class Library (BCL). For unmanaged environments, there is MSXML. None so far, except an initial implementation as part of ASP.NET AJAX.
Platform and language Parsers and formatters are widely available on many platforms and languages (commercial and open source implementations). Parsers and formatters are available already on many platforms and in many languages. Consult json.org for a good set of references. Most implementations for now tend to be open source projects.
Integrated language Industry vendors are currently experimenting with support literally within languages. See Microsoft's LINQ project for more information. Is natively supported in JavaScript/ECMAScript only.

Tags: ,

Learning resource | Technical

An inspiring concept video of what next-generation UX could be and what digital life might be

by Vahid 10. May 2009 03:51

i got the video from Nikhil Kothari blog. you got to check this out. watch and tell me how long is it going to take to be there?

Tags:

General

XPath expressions quick reference:

by Vahid 7. May 2009 07:00

  if you work with XML and xpath for sure the reference seems to be a trivial one for you. but if you stop working with xml and xpath for a while you’ll find the reference pretty handy. i personally keep it with me always. hope it also helps you.

the reference xpath expression is for this xml content:

   1: <?xml version="1.0" encoding="utf-8" ?>
   2: <Albums>
   3:   <Album country="USA">
   4:     <title>Empire Burlesque</title>
   5:     <artist>Bob Dylan</artist>
   6:     <price>10.90</price>
   7:   </Album>
   8:   <Album country="UK">
   9:     <title>Hide your heart</title>
  10:     <artist>Bonnie Tyler</artist>
  11:     <price>10.0</price>
  12:   </Album>
  13:   <Album country="USA">
  14:     <title>Greatest Hits</title>
  15:     <artist>Dolly Parton</artist>
  16:     <price>9.90</price>
  17:   </Album>
  18: </Albums>

and here is the quick reference

/Albums

selects the root element

/Albums/Album

selects all the Album elements of the Albums element

/Albums/Album/price

selects all the price elements of all the Album elements of the Albums element

/Albums/Album[price>10.0]

selects all the Album elements with price greater than 10.0

starts with a slash(/)

represents an absolute path to an element

starts with two slashes(//)

selects all elements that satisfy the criteria

//Album

selects all Album elements in the document

/Albums/Album/title | /Albums/Album/artist

selects all the title and artist elements of the Album elements of Albums

//title | //artist

selects all the title and artist elements in the document

/Albums/Album/*

selects all the child elements of all Album elements of the Albums element

/Albums/*/price

selects all the price elements that are grandchildren of Albums

/*/*/price

selects all price elements which have two ancestors

//*

selects all elements in the document

/Albums/Album[1]

selects the first Album child of Albums

/Albums/Album[last()]

selects the last Album child of Albums

/Albums/Album[price]

selects all the Album elements that have price

/Albums/Album[price=10.90]

selects Album elements with the price of 10.90

/Albums/Album[price=10.90]/price

selects all price elements with the price of 10.90

//@country

selects all "country" attributes

//Album[@country]

selects Album elements which have a "country" attribute

//Album[@*]

selects Album elements which have any attribute

//Album[@country='UK']

selects Album elements with "country" attribute equal to 'UK'

 

 

Tags: ,

Technical