Koistya `Navin's shared items in Google Reader

SQL Server 2008 Administration Instant Reference

2009-11-15T17:12:12Z

9780470496602 (0470496606), Sybex, 2009

Perfect companion to any SQL Server 2008 book, providing fast, accurate answers on the spot for millions of IT professionals

System and database administrators, IT consultants, and database application developers often need quick answers and practical solutions for SQL Server issues. This convenient guide offers you quick referencing for the product and database topics you need most.

If you're an IT administrator looking for the essentials in the day-to-day tasks of administering SQL Server 2008, you'll appreciate this book's design for providing quick and easy look up of solutions and tables, lists, and step-by-step instructions for answers on the spot. SQL Server 2008 Instant Administration Reference is a guide that you want to keep within reach.

SQL Server is Microsoft's bestselling database manager; the 2008 version offers enhanced security and high availability, encouraging users to upgrade
Features thumb tabs, secondary and tertiary tables of contents, and special heading treatments to provide quick and easy lookup, as well as quick-reference tables and lists to provide answers on the spot
Covers installing, configuring, managing, and maintaining SQL Server; optimizing server performance; and troubleshooting

SQL Server 2008 Administration Instant Reference answers the questions you encounter most often in your daily work.

Make your site run only in ONE Browser window(single instance)!

2009-11-15T10:49:00Z

While a was at Teched2009 and watching Tim Heuer presenting Silverlight 3 I noticed a new cool feature named Local Messaging!

When I saw this new feature, a crazy idea crossed my mind. Could this be used in order to allow the user to open my website in only one browser window?

The answer is yes! But not the way I first thought. Here is how (code in MainPage.xaml.cs):

string _localName = "SL App";
bool _Close = false;

public MainPage()
{
   InitializeComponent();

   Loaded += new RoutedEventHandler(MainPage_Loaded);
   try
   {
       LocalMessageReceiver incomingMessage = new LocalMessageReceiver(_localName);
       //Start listening
       incomingMessage.Listen();
   }
   catch (ListenFailedException)
   {
       _Close = true;
   }            
}

protected void MainPage_Loaded(object sender, RoutedEventArgs e)
{
   if (_Close)
   {
       HtmlPage.Window.SetProperty("location", "/InfoMessage.aspx");
   }
   else
   {
       LocalMessageSender msgSender = new LocalMessageSender(_localName);
       msgSender.SendAsync("New instance loaded");
   }
}

Loading Default.aspx

Clicking on the first link

Then on the second link

Those are the files in the solution

That’s an exception driven solution but works for me! :)

This works also across different browsers but if you want you can changed to allow one instance per browser.

Here are the solution files.

Enjoy!

Fun with Linq Aggregate

2009-11-15T11:40:00Z

Say we’ve got a CSV file:

private const string csv = 
@"1,2,3,4,5
6,7,8,9,10
11,12,13,14,15
16,17,18,19,20";

We want to parse it into nested List<int>, and then print out all the numbers on a single line. We might do it like this:

public void ParseCsvAndOutputAsString()
{
    var data = new List<List<int>>();

    foreach (var line in csv.Split('\n'))
    {
        var innerList = new List<int>();
        foreach (var item in line.Split(','))
        {
            innerList.Add(int.Parse(item));
        }
        data.Add(innerList);
    }

    string output = "";
    foreach (var innerList in data)
    {
        foreach (var item in innerList)
        {
            output = string.Format("{0} {1}", output, item);
        }
    }

    Console.WriteLine(output);
}

Yes, I know I should use a StringBuilder and AddRange, but ignore that for the moment, I’m trying to make a point here.

Taking a collection of values and reducing them down to a single value is a very common task in programming. Here we’re doing it twice; first we’re taking a string, splitting it apart and then reducing it down to a single reference to a List<List<int>>; then we’re taking the may items of data and reducing them to a string.

This is so common in fact, that many programming languages have some kind of ‘reduce’ functionality built in. It’s especially common with functional languages. Did you know that C# also has a reduce function? It’s the Aggregate extension method. Here’s the same method written in two statements with it:

[Test]
public void ParseCsvAndOutputAsStringUsingAgregate()
{
    var data = csv
        .Split('\n')
        .Aggregate(
            new List<List<int>>(),
            (list, line) => list.Append(line
                .Split(',')
                .Select(str => int.Parse(str))
                .Aggregate(
                    new List<int>(),
                    (innerList, item) => innerList.Append(item))));

    Console.WriteLine(data
        .SelectMany(innerList => innerList)
        .Aggregate("", (output, item) => string.Format("{0} {1}", output, item)));
}

Aggregate takes two parameters; the first sets up the initial value, in our case we create new instances of List<List<int>>, List<int> and an empty string, this is known as the ‘accumulator’; the second is the function that does the accumulating.

Aggregate works really well with fluent interfaces, where methods return their instance. I’ve added a fluent ‘Append’ extension method to List<int> to help me here:

public static List<T> Append<T>(this List<T> list, T item)
{
    list.Add(item);
    return list;
}

So any time you’ve got a collection of stuff that you want to ‘reduce’ to a single item, remember Aggregate.

[Tip] Enable Visual Studio 2010 Online Template/Extension usage

2009-11-14T20:16:51Z

Microsoft Visual Studio 2010 uses a new feature called the Extension Manager to add, remove, enable, and disable Visual Studio extensions. The Extension manager has a UI similar to that of the Windows Control Panel, and can be opened from the Tools menu in Visual Studio by selecting Extension Manager….

In addition, third party templates may now be installed from the New Project Dialog Box by clicking Search Online Templates… in the Templates pane.

To Enable Online Extensions download and usage, follow the below steps:

From Visual Studio 2010 go to Options
Extension Manager
Check “Load per used extensions when running as administrator”

P.S. if you don’t have this option installed Visual Studio will notify you when selecting “Online Templates” from New Project dialog.

Digital Photography For The Web

2009-11-15T00:04:49Z

Digital Photography For The Web

Published on Nov 15, 2009 by SitePoint. Author(s): Paul Duncanson

A hands-on on guide to digital photography, with a practical focus on the Web. Readers will learn how to make the most of their digital camera, while learning the basics of composition, exposures, filters and more. Photography is an incredibly hot category, but no book on the market takes into account the millions of people who use their digital cameras for the explicit purpose of using the images on the Web – whether sharing with their friends via Facebook and Flickr to taking product shots and participating in stock photography sites like iStockPhoto and Fotolia.

More Books...

Windows PowerShell 2 For Dummies (Computer/Tech)

2009-11-12T15:10:55Z

9780470371985 (0470371986), For Dummies, 2009

Prepare for the future of Microsoft automation with this no-nonsense guide

Windows PowerShell 2 is the scripting language that enables automation within the Windows operating system. Packed with powerful new features, this latest version is complex, and Windows PowerShell 2 For Dummies is the perfect guide to help system administrators get up to speed.

Written by a Microsoft MVP with direct access to the program managers and developers, this book covers every new feature of Windows PowerShell 2 in a friendly, easy-to-follow format.

Windows PowerShell 2 is the updated scripting language that enables system administrators to automate Windows operating systems
System administrators with limited scripting experience will find this book helps them learn the fundamentals of Windows PowerShell 2 quickly and easily
Translates the jargon and complex syntax of Windows PowerShell 2
Covers script debugging improvements, the ability to invoke commands remotely, and the new user interface
Uses real-world applications to clarify the theory, fundamentals, and techniques of the scripting language
Written by a Microsoft MVP with direct access to the developers of Windows PowerShell 2

Windows PowerShell 2 For Dummies makes this tool easily accessible to administrators of every experience level.

ASP.NET MVC 1.0 Test Driven Development: Problem - Design - Solution (Wrox Programmer to Programmer)

2009-11-12T15:12:24Z

9780470447628 (0470447621), Wrox Press, 2009

A hands-on journey takes you through the development process of a Web application from concept to production

ASP.NET MVC is a new Web development framework created by Microsoft as an alternative to ASP.NET web forms applications. MVC is well suited to testability, and Test Driven Development (TDD) affords you a generous level of control while also making MVC very powerful and extensible. This book takes the ASP.NET MVC and combines it with a testing methodology and tools and guides you through the process of taking Web application from concept to production.

Using a complete working sample application that demonstrates all the tools needed to build an e-commerce Web application, the popular Problem – Design – Solution format gradually introduces you to new alternative tools, frameworks, and methodologies to get you started creating cutting-edge Web applications.

ASP.NET MVC is Microsoft's hot new Web development framework to use as an alternative to ASP.NET Web forms applications
Use the popular Problem – Design – Solution recipe and encourages you to get involved with developing a Web application from concept to production
Introduces new alternative tools, frameworks, and methodologies, such as nUnit and Inversion of Control containers
Shows you how to use open source JavaScript libraries and work with a mocking framework

As you work with all facets of Web application development-requirements, design, testing, deployment, beta releases, refactoring, tool, and framework selection-you will have developed a live Web application by the time the book is finished.

Note: CD-ROM/DVD and other supplementary materials are not included as part of eBook file.

Ultra-fast ASP.NET: Build Ultra-Fast and Ultra-Scalable Websites Using ASP.NET and SQL Server

2009-11-12T15:14:55Z

9781430223832 (1430223839), Apress, 2009

Ultra-Fast ASP.NET presents a practical approach to building fast and scalable web sites using ASP.NET and SQL Server. In addition to a wealth of tips, tricks and secrets, you'll find advice and code examples for all tiers of your application, including the client, caching, IIS 7, ASP.NET, threads, session state, SQL Server, Analysis Services, infrastructure and operations. By applying the ultra-fast approach to your projects, you’ll squeeze every last ounce of performance out of your code and infrastructure—giving your site unrivaled speed.

The approach is mostly prescriptive; rather than drowning you in options, the book presents and explains specific high-impact recommendations and demonstrates them with detailed examples. Using this knowledge, you will soon be building high-performance web sites that scale easily as your site grows.

Pro SQL Server 2008 Mirroring

2009-11-12T15:16:14Z

9781430224235 (1430224231), Apress, 2009

Pro SQL Server 2008 Mirroring is your complete guide to planning, using, deploying, and maintaining database mirroring as a high-availability option. Mirroring protects you by maintaining one or more duplicate copies of your database for use in the event the primary copy is damaged. It is a key component of any production-level, high-availability solution. This book covers the full spectrum of database mirroring, taking you from the planning phase through the implementation to the maintenance phase and beyond.

Easy to follow, step-by-step instructions for beginner and intermediate users
In-depth, detailed information for advanced and expert users
Covers all phases of database mirroring from planning to sustained maintenance

.NET 4.0 is to Lazy

2009-11-10T13:10:00Z

With .NET 4.0 there is a new class added to the System namespace called Lazy<T>. This class is what the name says, lazy. Here is an example where Lazy is used:

var lazy = new Lazy<IList<OrderRow>>(
                                () =>
                                {
                                        var rows = //get order rows;
                                        return rows;
                                });

var rows = lazy.Value;

The Lazy<T>’s constructor can take a Func<T> as an argument, the function passed as an argument to the contractor will first be invoked when the Value property of the Lazy<T> class is used, but not invoked the next time the Value property is used. The code above will first execute the function passed as an argument when the we request the value of the Lazy<T>, the returned value of the function will be cached. The next time Value is used, the function will not be invoked, instead the cached value will be returned. This class can for example be used when we want some kind of Lazy Loading.

I’m on twitter: http://www.twitter.com/fredrikn

New MSDN Library views

2009-11-06T23:07:00Z

In this video, Mark D'Urso, a Senior Development Lead on the Library Experience Team, demonstrates the new Library views on MSDN:

Lightweight view

ScriptFree view

Classic view

Kathleen McGrath
Visual Studio User Education
http://blogs.msdn.com/kathleen
Visual Studio and .NET Framework Content Survey

Inside Microsoft patterns & practices: Dependency Injection in Libraries

2009-11-16T00:00:00Z

November 2009

This article discusses how to write a library or framework that uses the Dependency Injection pattern and how the change in focus affects the usage of the pattern.

N-Tier Apps and the Entity Framework: Building N-Tier Apps with EF4

2009-11-16T00:00:00Z

November 2009

This article is the third in a series about n-tier programming with the Entity Framework, specifically about building custom Web services with the Entity Framework and WCF. This article looks at features coming in the second release of the Entity Framework (EF4) and how you use them to implement the Self-Tracking Entities and Data Transfer Objects (DTOs) n-tier patterns.

In response to "The Dangers of Single Responsibility in Programming"

2009-11-10T19:55:00Z

David Cooksey writes an interesting article titled "The Dangers of Single Responsibility in Programming" in which he proposes that there is a certain level of granularity below which SRP is not appropriate. Although I understand where he's coming from, I tend to disagree with his conclusion, and I think it's because his hypothetical programmer didn't actually find the right responsibilities, not because the method was already granular enough. I'd propose a slightly different breakdown of the responsibilities, leveraging Inversion of Control and creating several Pricing Calculators that each handle a different kind of discount (In his scenario, there are Sales prices and Gold Level Discounts). I would see each of these items as their own calculator, and a separate "Pricer" class that would use each of these. Note that in a real application I would probably leverage something like StructureMap to find all classes that implement IPriceCalculator and have some way to control the orderring of these (probably a Priority field on the IPriceCalculator interface to sort by) but to keep things simple I'm hard-coding the calculators list in this example. So, something like this:

   public interface IProduct
    {
        decimal BasePrice { get; }
        decimal SalesPrice { get; }
        decimal GoldLevelDiscount { get; }
        bool IsOnSale { get; }
    }
 
    public interface ICustomer
    {
        bool HasFixedDiscountAgreement { get; }
        decimal FixedDiscount { get; }
        bool IsGoldLevelCustomer { get; }
    }
 
    public class Pricer
    {
        private List<IPriceCalculator> _calculators = new List<IPriceCalculator>
          {
              new GoldLevelPriceCalculator(),
              new SalePriceCalculator()
          };
        public decimal GetPrice(IProduct product, ICustomer customer)
        {
            decimal price = product.BasePrice;
            foreach (IPriceCalculator calculator in _calculators)
            {
                price = calculator.CalculatePrice(price, customer, product);
            }
            return price;
        }
    }
 
    public interface IPriceCalculator
    {
        decimal CalculatePrice(decimal price, ICustomer customer, IProduct product);
    }
 
    public class GoldLevelPriceCalculator: IPriceCalculator
    {
        public decimal CalculatePrice(decimal price, ICustomer customer, IProduct product)
        {
            if (customer.IsGoldLevelCustomer)
            {
                price = price*(1 - product.GoldLevelDiscount);
            }
            return price;
        }
    }
 
    public class SalePriceCalculator: IPriceCalculator
    {
        public decimal CalculatePrice(decimal price, ICustomer customer, IProduct product)
        {
            if (product.IsOnSale && !customer.HasFixedDiscountAgreement)
            {
                price = product.SalesPrice < price ? product.SalesPrice : price;
            }
            return price;
        }
    }

Notice that now, each type of discount is contained in its own class which takes the customer, product, and current price and applies its business rules to the price. In this way, the GetPrice method isn't going to turn into a Monster Method as new business rules are added. Also notice that it's easy to add a new pricing calculator. So, for grins, let's add the "FixedDiscount" version alluded to in David's example. First, create a new price calculator:

public class FixedDiscountCalculator: IPriceCalculator
    {
        public decimal CalculatePrice(decimal price, ICustomer customer, IProduct product)
        {
            if (customer.HasFixedDiscountAgreement)
            {
                price = price*(1 - customer.FixedDiscount);
            }
            return price;
        }
    }

Now, we simply add this to the collection of price calculator used by our pricer (again, this would be handled by our DI container of choice in the real world):

private List<IPriceCalculator> _calculators = new List<IPriceCalculator>
                                                          {
                                                              new GoldLevelPriceCalculator(),
                                                              new SalePriceCalculator(),
                                                              new FixedDiscountCalculator()
                                                          };

And we're done. Now, we've got a well-factored system which follows SRP and is easily extendable with new pricing rules (which, I would assume, could become significantly more complex than the examples given).

Well, we're not really done - if the theoretical developer had actually modified this original functionality in a Test-driven manner, you'd have a large number of unit tests to prove that you didn't break anything when you added the new FixedDiscountCalculator. Note that I'm a fan of RhinoMocks, and leveraged it so I don't actually care about where my customer or product information comes from (there's actually no implementation of these interfaces at all - they should be loaded using your favorite repository-pattern-ORM-leveraging-code). For the sake of keeping this post short, I've uploaded the complete source with unit tests as PricingCalculator.txt - rename to .cs, add NUnit and RhinoMocks references, and you're good to go.

In conclusion, Is SRP dangerous? IMHO, not when properly applied. But that's true for most SOLID principles - you need to know how to apply them appropriately.

Writing good documentation (part 1)

2009-11-11T07:13:57Z

Writing good documentation (part 1). Jacob explains some of the philosophy behind Django’s documentation. Topical guides are particularly interesting—many projects skip them (leaving books to fill the gap) but they fill an essential gap between tutorials and low-level reference documentation.

Facebook Toolkit for Microsoft Developers

2009-11-11T13:42:00Z

Build your own FaceBook applications with ASP.NET, ASP.NET MVC, WinForms or Silverlight ! Read More Download the SDK Facebook.dll : This is the main assembly that will be used by all applications. This has all the logic to handle communication with the...(read more)

SyncToy 2.1 Available for Download

2009-11-11T19:59:00Z

How many times have you tried to copy a huge number of files only to accidently hit space or escape cancelling the transfer and you don't want to re-start from scratch? Well there's a better way to sync files between directories and drives, SyncToy. You might remember this from the XP PowerToys days, the ease of use makes it a very popular download. Deepa from the Sync team stopped by to show us the latest version, SyncToy 2.1.

You can find out more here, download it here, or give the team feedback here.

ASP.NET 4 "Quick Hit" - Auto Start

2009-11-11T18:48:00Z

In this video you will learn about the new auto-start scalability feature which provides a controlled approach for starting up an application pool, initializing an ASP.NET application, and then accepting HTTP requests.

ASP.NET 4 "Quick Hit" - Imperative WebForms Routing

2009-11-05T05:00:00Z

In this video you will learn how to use an expression builder to do WebForms routing imperatively.

Visual Studio 2010 "Quick Hit" - Snippets IntelliSense

2009-11-11T05:00:00Z

In this video you will learn about Visual Studio's snippet support of HTML, ASP.NET markup and JavaScript.