Manitra.net » C# http://www.manitra.net/blog Ideas on C# .NET Wed, 01 Feb 2012 13:45:53 +0000 en hourly 1 http://wordpress.org/?v=3.0.1 Sweet DevTools http://www.manitra.net/blog/dev/csharp/sweet-devtools/ http://www.manitra.net/blog/dev/csharp/sweet-devtools/#comments Tue, 25 Oct 2011 20:38:23 +0000 manitra http://www.manitra.net/blog/?p=301 I just published few online tools for developers at devtools.manitra.net and I hope they will allow you to save time. The widgets currently available are :

Those tools already exist on the web but the key stuffs here is that they are :

  • tiny (minimalist web page without blabla about what a base64 encoding is etc ..)
  • embeddable as widget
  • free and ad-free

By the way, they are best used within a netvibes dashboard (Web Page Widget).

Enjoy :)

]]> http://www.manitra.net/blog/dev/csharp/sweet-devtools/feed/ 0 How to create deeply nested Asp.net Dynamic Controls ? http://www.manitra.net/blog/dev/csharp/how-to-create-deeply-nested-asp-net-dynamic-controls/ http://www.manitra.net/blog/dev/csharp/how-to-create-deeply-nested-asp-net-dynamic-controls/#comments Tue, 28 Sep 2010 20:02:08 +0000 manitra http://www.manitra.net/blog/?p=211 Creating controls at runtime (dynamic controls) in Asp.net is both tricky and unintuitive. This article will explain a pattern to make it easier.

The main advantages of this strategy are :
- ability to create deeply nested controls with unlimited depth
- each dynamicaly created controls have normal states (Viewstate is not broken)
- you can create those controls whenever you want (including OnClick events, PreRender and Render phases)
- no hacks with postback arguments are required

[UPDATE (2011/08/01)] : “M” found that the PersistentPanel doesn’t work well when it is instantiated in a markup file (aspx/ascx/master …) so I would advice you to instanciate it via code in the CreateChildControl method. The source code in the bottom of the page have been updated to reflect that.

The online demo

To help you understand what am I talking about here is an online example of deeply nested and dynamically created controls using Asp.Net.

You can create as much nested controls as you want and test that each controls persists its state upon postbacks.

The implementation

The PersistentPanel

The PersistentPanel is just a Panel wich persists its child controls collection using the viewstate automatically. This is a key control because it recreates the dynamically created controls on each post back during the right life-cycle phase : OnLoadViewstate. Thanks to this early recreation, those controls can persist their state in the ViewState like any controls declared in the markup page during the design time.

This kind of component is quite common now a days but the particularity here is that I do not try to persits all the nested controls but only the direct children. Indeed, if you try to persist and recreate the whole hierarchy, you’ll encounter problems and will have to handle a lot of special cases. More over since event handlers are not persisted, the restored components wont work.

The implementation process of the PersitentPanel :

  • during the save process of the viewstate we save the control hierarchy (type+Id only) using a serializable entity that store the control type, its Id and and a list of children
  • during the restore process of the viewstate we refill the Controls collection using the previously saved control hierarchy
  1.     public class PersistentPanel : Panel
  2.     {
  3.         private static string ControlsViewStateKey = "Controls";
  4.         public int MaxDepth
  5.         {
  6.             get
  7.             {
  8.                 var value = ViewState["MaxDepth"];
  9.                 if (value != null) return (int)value;
  10.                 return 1;
  11.             }
  12.             set
  13.             {
  14.                 ViewState["MaxDepth"] = value;
  15.             }
  16.         }
  17.  
  18.         protected override void LoadViewState(object savedState)
  19.         {
  20.             base.LoadViewState(savedState);
  21.             var persisted = (ControlEntity)ViewState[ControlsViewStateKey];
  22.             if (persisted != null)
  23.                 foreach (var child in persisted.Children)
  24.                     Controls.Add(child.ToControl());
  25.         }
  26.  
  27.         protected override object SaveViewState()
  28.         {
  29.             ViewState[ControlsViewStateKey] = new ControlEntity(this, MaxDepth);
  30.             var result = base.SaveViewState();
  31.             return result;
  32.         }
  33.     }

The parent of the dynamic controls

The component wich will dynamicaly create the controls will first embed a PersistentPanel. And each time it will want to add a control it will add that control in the PersistentPanel’s controls collection. Here is an example :

  1. public class CustomerView : Page {
  2.     private PersistentPanel ctlPanel;
  3.     // —— //
  4.     protected void ctlAdd_click(object sender, EventArgs e){
  5.         ctlPanel.Controls.Add(new Textbox{Text=Datetime.Now.ToString();});
  6.     }
  7.  
  8. }

Combining both to build a hierarchical data editor

Now we have a persistant panel and know that dynamically created controls are persisted, we’ll create a control that would create other complexes controls wich will have the same type as their creator. This would give us a powerfull control that would be able to display or edit hierarchical data wich, in our case, is a filter expression. We’ll have
- a control to edit scalar filter
- a control to edit composite filter
The scalar filter will just contain 3 simple controls for the field name, the operator and the value. The composite filter editor will be the interesting one. Indeed, it’s gonna contains a variable number of scalar editor and other composite filter editor. So it will use a persistant panel to host those nested controls. And that’s it !

  1. public class compositeView : WebControl, INamingContainer

Conclusion

The important things to remember are that :
- a control can be created at anytime, but it must be recreated on each postback during/before the LoadViewState of its container
- the ID of the dynamic control must be the same
- event handlers are not persisted, you have to rewire them up on each postback, the PersistantPanel has the ControlRestored event wich is the best place to do so.

Download the source code

The online demo application is available here :

Have fun !

]]> http://www.manitra.net/blog/dev/csharp/how-to-create-deeply-nested-asp-net-dynamic-controls/feed/ 13 Concise C# Part 3 : C# 3 shortcuts http://www.manitra.net/blog/dev/csharp/concise-c-part-3-c-3-shortcuts/ http://www.manitra.net/blog/dev/csharp/concise-c-part-3-c-3-shortcuts/#comments Mon, 07 Sep 2009 21:27:06 +0000 manitra http://www.manitra.net/blog/?p=158 The version 3 of C# brings us a lot of syntactic sugar to reduce the length of our code. Here are some of them.

This post is part of a serie about making C# code shorter.

Constructors with Property initializers

  1. //Verbose and Ugly
  2. Post value = new Post();
  3. value.Title = "New Version For C#";
  4. value.CreatedOn = DateTime.Now;
  5. CreatePost(value);
  6.  
  7. //Concise and Sweet
  8. CreatePost(new Post
  9. {
  10.     Title = "NewVersion For C#",
  11.     CreatedOn = DateTime.Now
  12. });

Collection initializers

  1. //Verbose and Ugly
  2. var names = new List<string>();
  3. names.Add("manitra");
  4. names.Add("yeah");
  5. SaveNames(names);
  6.  
  7. //Concise and Sweet
  8. SaveNames(new List<string> { "manitra", "yeah" });

Var keyword

  1. //Verbose and Ugly
  2. Dictionary<string, List<Post>> result = new Dictionary<string, List<Post>>();
  3.  
  4. //Concise and Sweet (But still strongly typed)
  5. var result = new Dictionary<string, List<Post>>();

Automatic properties

  1. //Verbose and Ugly
  2. public class Post
  3. {
  4.     private string title;
  5.     private string description;
  6.     private DateTime createdOn;
  7.  
  8.     public string Title
  9.     {
  10.         get
  11.         {
  12.             return this.title;
  13.         }
  14.         set
  15.         {
  16.             this.title = value;
  17.         }
  18.     }
  19.  
  20.     public string Description
  21.     {
  22.         get
  23.         {
  24.             return this.description;
  25.         }
  26.         set
  27.         {
  28.             this.description = value;
  29.         }
  30.     }
  31.  
  32.     public System.DateTime CreatedOn
  33.     {
  34.         get
  35.         {
  36.             return this.createdOn;
  37.         }
  38.         set
  39.         {
  40.             this.createdOn = value;
  41.         }
  42.     }
  43. }
  44.  
  45. //Concise and Sweet
  46. public class Post
  47. {
  48.     public string Title { get; set; }
  49.     public string Description { get; set; }
  50.     public DateTime CreatedOn { get; set; }
  51. }
]]> http://www.manitra.net/blog/dev/csharp/concise-c-part-3-c-3-shortcuts/feed/ 0 Concise C# Part 2 : Try Catch and reusability http://www.manitra.net/blog/dev/csharp/concise-c-part-2-try-catch-and-reusability/ http://www.manitra.net/blog/dev/csharp/concise-c-part-2-try-catch-and-reusability/#comments Wed, 02 Sep 2009 22:03:20 +0000 manitra http://www.manitra.net/blog/?p=147 Exception handling is an important part of any software. In this post, I will talk about a trick to make but some kind of reusability on exception handling.

This post is part of a serie about making C# code shorter

When you write code, you usually try to reuse your code by creating methods and calling those methods each time you the need their functionality. When working with exceptions, it’s a bit tricky because, they don’t follow the normal code flow, they jump out of your method … unless you catch them. The consequence is that you usually have multiple similar try {} catch {} blocks that are often copied and pasted.

This is what usually happens

  1. public void Method1()
  2. {
  3.     try
  4.     {
  5.         //method 1 content
  6.     }
  7.     catch (ThreadAbortException)
  8.     {
  9.     }
  10.     catch (IOException ex)
  11.     {
  12.         //IO exception handling
  13.     }
  14.     finally
  15.     {
  16.         //add any code for releasing ressource
  17.     }
  18. }
  19.  
  20. public void Method2()
  21. {
  22.     try
  23.     {
  24.         //method 2 content
  25.     }
  26.     catch (ThreadAbortException)
  27.     {
  28.     }
  29.     catch (IOException ex)
  30.     {
  31.         //IO exception handling
  32.     }
  33.     finally
  34.     {
  35.         //add any code for releasing ressource
  36.     }
  37. }

The solution to reuse the exception block

This is what you could do to reuse the same error handling code block in c# :

  1. public void Method1()
  2. {
  3.     Do(() =>
  4.     {
  5.         //method 1 content
  6.     });
  7. }
  8.  
  9. public void Method2()
  10. {
  11.     Do(() =>
  12.     {
  13.         //method 2 content
  14.     });
  15. }
  16.  
  17. protected void Do(Action method)
  18. {
  19.     try
  20.     {
  21.         //code to call before each methods
  22.         method();
  23.         //code to call after each methods success
  24.     }
  25.     catch (ThreadAbortException)
  26.     {
  27.     }
  28.     catch (IOException ex)
  29.     {
  30.         //IO exception handling
  31.     }
  32.     finally
  33.     {
  34.         //add any code for releasing ressource
  35.     }
  36. }
]]> http://www.manitra.net/blog/dev/csharp/concise-c-part-2-try-catch-and-reusability/feed/ 0 Concise C# Part 1 : Extension methods and Linq http://www.manitra.net/blog/dev/csharp/concise-c-part-1-extension-methods-and-linq/ http://www.manitra.net/blog/dev/csharp/concise-c-part-1-extension-methods-and-linq/#comments Thu, 27 Aug 2009 20:44:24 +0000 manitra http://www.manitra.net/blog/?p=48 Because, short code is easier to understand, I decided to publish some posts about making C# code shorter. I’ll talk about small tricks I use to significantly reduce the amount of code I write to achieve my goals. Some people don’t agree with that idea because there has been abuses done by perl and c programmer in the past. I think that, if you use correct names for methods, variable and types, the shortest code will still be easy to understand.

This post is part of a serie about making C# code shorter

In this post, I’ll use the following class for my examples :

  1. public class Post
  2. {
  3.     public int Id { get; set; }
  4.     public string Author { get; set; }
  5.     public string Title { get; set; }
  6.     public string Content { get; set; }
  7. }

Linq extension methods

Linq is a set of contracts (interfaces) wich allow the developper to request objects from a data store. What make it unique is that :
- the query language is strongly typed (at compile time you are sure that all column names et types are corrects and that there are no missin semi-colon
- it supports unlimited data store type (including all database systems, xml files, google data, twitter posts, in memory objects …)

I’ll focus primarily on Linq to Objects (in memory object) because we’re talking about making code concise. So here are the shortcuts !

Searching an unique element in a collection

  1. //Concise and Sweet
  2. public Post GetById(int id, IList<Post> posts)
  3. {
  4.     return posts.FirstOrDefault(p => p.Id == id);
  5. }
  6.  
  7. //Verbose and Ugly
  8. public Post GetById(int id, IList<Post> posts)
  9. {
  10.     foreach (Post current in posts)
  11.     {
  12.         if (current.Id == id)
  13.         {
  14.             return current;
  15.         }
  16.     }
  17. }

Filtering a collection

  1. //Concise and Sweet
  2. public IList<Post> FindByAuthor(string author, IList<Post> posts)
  3. {
  4.     return posts.Where(p => p.Author == author).ToList();
  5. }
  6.  
  7. //Verbose and Ugly
  8. public IList<Post> FindByAuthor(string author, IList<Post> posts)
  9. {
  10.     List<Post> result = new List<Post>();
  11.     foreach (Post current in posts)
  12.     {
  13.         if (current.Author == author)
  14.         {
  15.             result.Add(current);
  16.         }
  17.     }
  18.     return result;
  19. }

Selecting a column (one property of an object collection)

  1. //Concise and Sweet
  2. public IList<string> ExtractTitles(IList<Post> posts)
  3. {
  4.     return posts.Select(p => p.Title).ToList();
  5. }
  6.  
  7. //Verbose and Ugly
  8. public IList<string> ExtractTitles(IList<Post> posts)
  9. {
  10.     List<string> result = new List<string>();
  11.     foreach (Post current in posts)
  12.     {
  13.         result.Add(current.Title);
  14.     }
  15.     return result;
  16. }

Apply changes to a collection

  1. //Concise and Sweet
  2. public IList<Post> Anonymize(IList<Post> posts)
  3. {
  4.     return posts.Select(p => new Post
  5.     {
  6.         Id = p.Id,
  7.         Title = p.Title,
  8.         Author = "***",
  9.         Content = p.Content
  10.     }).ToList();
  11. }
  12.  
  13. //Verbose and Ugly
  14. public IList<Post> Anonymize(IList<Post> posts)
  15. {
  16.     List<Post> result = new List<Post>();
  17.     foreach (Post current in posts)
  18.     {
  19.         Post anonymousPost = new Post();
  20.         anonymousPost.Id = current.Id;
  21.         anonymousPost.Title = current.Title;
  22.         anonymousPost.Author = "***";
  23.         anonymousPost.Content = current.Content;
  24.         result.Add(anonymousPost);
  25.     }
  26.     return result;
  27. }

Creating your own extension methods

Extension methods are the best candidates when you plan to build your very own low level toolset. Here are some examples to give you an idea.

  1. public static class MyExtensions
  2. {
  3.     //Index a collection by its key
  4.     public static IDictionary<TKey, TObject> IndexBy<TObject, TKey>(this IEnumerable<TObject> target, Func<TObject, TKey> keyExtractor)
  5.     {
  6.  
  7.         var result = new Dictionary<TKey, TObject>();
  8.         foreach (var current in target)
  9.             result[keyExtractor(current)] = current;
  10.         return result;
  11.     }
  12.  
  13.     //Joining any collection of string (array, list, enumerable …)
  14.     public static string Join(this IEnumerable<string> elements, string separator)
  15.     {
  16.         return string.Join(separator, elements.ToArray());
  17.     }
  18. }
]]> http://www.manitra.net/blog/dev/csharp/concise-c-part-1-extension-methods-and-linq/feed/ 0 Asynchronous tasks on Winform http://www.manitra.net/blog/dev/asynchronous-tasks-on-winforms/ http://www.manitra.net/blog/dev/asynchronous-tasks-on-winforms/#comments Mon, 11 May 2009 00:33:51 +0000 manitra http://www.manitra.net/blog/?p=32 The problem

When you create winform applications, doing tasks in the background is essential to avoid user frustation. Unfortunatly, it could make you write a lot more code. Here are some utility methods that reduce the complexity of asynchronous calls within windows forms.

Within you base class

You probably have a common base class for all your UI components. Add these methods :

  1. namespace TestWinForm
  2. {
  3.     public class BaseForm : Form
  4.     {
  5.         // Execute some code in async mode.
  6.         // When it's done, it calls the nextStep delegate, eventually with
  7.         // an exception catched during the main action.
  8.         protected virtual void Async(Action action, Action nextStep)
  9.         {
  10.             new Thread(delegate()
  11.             {
  12.                 Exception exception = null;
  13.                 try
  14.                 {
  15.                     action();
  16.                 }
  17.                 catch (Exception ex)
  18.                 {
  19.                     exception = ex;
  20.                 }
  21.                 ThreadSafe(() =&gt; { nextStep(exception ); });
  22.             }).Start();
  23.         }
  24.  
  25.         // This allows a sub class to easily run a method within
  26.         // an UI thread without the need of creating multiple
  27.         // delegate signatures for each method signatures
  28.         protected virtual void ThreadSafe(MethodInvoker method)
  29.         {
  30.             if (InvokeRequired)
  31.                 Invoke(method);
  32.             else
  33.                 method();
  34.         }
  35.     }
  36. }

Within your UI classes

Now the only thing you need to do is to encapsulate the methode content with the Async() method :

namespace TestWinForm
  1. {
  2.     public partial class MainForm : BaseForm
  3.     {
  4.         public MainForm()
  5.         {
  6.             InitializeComponent();
  7.         }
  8.  
  9.         // Here is the async trick :
  10.         // – UI will NOT freeze,
  11.         // – you can add beautifull animated gifs
  12.         private void button1_Click(object sender, EventArgs e)
  13.         {
  14.             DateTime? result = null;
  15.             Async(
  16.                 () =&gt;
  17.                 {
  18.                     result = GetComplexDate();
  19.                 },
  20.                 (ex) =&gt;
  21.                 {
  22.                     if (ex == null)
  23.                         textBox1.Text = result.Value.ToShortDateString();
  24.                     else
  25.                         textBox1.Text = ex.Message;
  26.                 }
  27.             );
  28.         }
  29.  
  30.         // This is the slow, data-intensive task :p
  31.         private DateTime? GetComplexDate()
  32.         {
  33.             Thread.Sleep(3000);
  34.             return DateTime.Now;
  35.         }
  36.     }
  37. }

The traditional way

Just in case you didn’t get it. This is what you should NOT DO:

// This was traditional way :
  1.         // – UI will freeze until during 3 second …
  2.         // – you users will complain
  3.         // avoid this !
  4.         private void button1_Click2(object sender, EventArgs e)
  5.         {
  6.             try
  7.             {
  8.                 textBox1.Text = GetComplexDate().ToShortDateString();
  9.             }
  10.             catch (Exception ex)
  11.             {
  12.                 textBox1.Text = ex.Message;
  13.             }
  14.         }

Happy coding !

]]> http://www.manitra.net/blog/dev/asynchronous-tasks-on-winforms/feed/ 2 Make InvokeRequired/Invoke easy http://www.manitra.net/blog/dev/invokerequiredinvoke-easier/ http://www.manitra.net/blog/dev/invokerequiredinvoke-easier/#comments Fri, 23 Jan 2009 21:31:30 +0000 manitra http://www.manitra.net/blog/?p=31 The problem

If you’re working on WinForms, you must know that you cannot call controls methods within a thread that is not the one that created those controls. To solve this problem, Microsoft recommend us to use the following code :

  1. namespace TestWinForm
  2. {
  3.     public partial class MainForm : BaseForm
  4.     {
  5.         public MainForm()
  6.         {
  7.             InitializeComponent();
  8.         }
  9.         // a delegate that has been created specially for this method
  10.         private delegate void DisplayDelegate(string text);
  11.  
  12.         // a method that may be called from a worker thread
  13.         public virtual void Display(string text)
  14.         {
  15.             if (InvokeRequired)
  16.             {
  17.                 Invoke(new DisplayDelegate(Display));
  18.             }
  19.             else
  20.             {
  21.                 //the actual job is here
  22.                 textBox1.AppendText(text);
  23.             }
  24.         }
  25.     }
  26. }

This code is ugly because :

  • you need to create a delegate for each single public method you can call from outside
  • you need to put an “if/else” block in each method wich increase the complexity of your code

The trick

Here is a trick that could significantly reduce the amount of code needed to do the same job within a large project.

Within you base class

You probably have a common base class for all your UI components. Add this method :

  1. namespace TestWinForm
  2. {
  3.     public class BaseForm : Form
  4.     {
  5.         // This allows a sub class to easily run a method within
  6.         // an UI thread without the need of creating multiple
  7.         // delegate signatures for each method signatures
  8.         protected virtual void ThreadSafe(MethodInvoker method)
  9.         {
  10.             if (InvokeRequired)
  11.                 Invoke(method);
  12.             else
  13.                 method();
  14.         }
  15.     }
  16. }

Within your UI classes

Now the only thing you need to do is to encapsulate the methode content with the ThreadSafe() method :

  1. namespace TestWinForm
  2. {
  3.     public partial class MainForm : BaseForm
  4.     {
  5.         public MainForm()
  6.         {
  7.             InitializeComponent();
  8.         }
  9.  
  10.         // public method that may be called from outside and within any
  11.         // worker thread …
  12.         public virtual void Display(string text)
  13.         {
  14.             ThreadSafe(delegate
  15.             {
  16.                 //do any UI related code here
  17.                 //note that because this is an anonym method,
  18.                 //you can use the local parameter
  19.                 textBox1.AppendText(text);
  20.             });
  21.         }

Happy coding !

]]> http://www.manitra.net/blog/dev/invokerequiredinvoke-easier/feed/ 5 A .NET fault tolerant web service framework implementation http://www.manitra.net/blog/dev/fault-tolerant-web-service-framework-implementation/ http://www.manitra.net/blog/dev/fault-tolerant-web-service-framework-implementation/#comments Tue, 29 Jul 2008 13:20:31 +0000 manitra http://www.manitra.net/blog/?p=24 Here is a .NET implementation of a fault tolerant web service framework.

The idea

One of the bad sides of web services is that they just regularly fail. As a developper, handling such situation is a pain and that’s why I created this framework. It has two main parts :

  • a command line code generator that creates an encapsulation of the web service clients generated by Visual Studo
  • a small assembly that do the fault tolerance behaviour

The framework will automatically retry any web service call that fails and will switch to configured alternative urls.

Features

  • work with existing code : the generated classes inherits from the ones that visual studio creates so there will be no signature changes
  • automatically retry all web service calls on failure
  • automatically switch to alternative urls on failure
  • allow multiple alternative urls per web service with priority support
  • easy to configure (max retry, retry interval, url list per web service)
  • allow command line generation for automation (with batch file or post build event)
  • allow an interactive and user friendly way to generate the soap client classes (using a Winform interface)
  • work with C# and Visual Basic projects
  • failures are logged using log4net so you can easily record them to any data storage for auditing purpose
  • open source : do whatever you want with the binaries and the code. Just share you enhancements

Files

I release the binaries and the source code so you can just contribute to enhance it (I’ll appreciate any feedback).

How to install and use it

Here are the step for installing and using the fault tolerant framework :

Basic steps

  • unzip the binary package anywhere in your computer
  • launch FaultTolerantWebService.Ui.exe
  • click the “Load” button and select the .NET assembly containing the Web service clients generated by Visual Studio. You can see the generated code in the main text box now.
  • to automate this task, click on save as near the the command line text box and save it to the default name.
  • add a reference to the FaultTolerantWebService.Common.dll in the project containing the Web refences.
  • add the generated file named FaultTolerantWebService.cs in your project (by default, it will located on the root of your project )

You’re done ! Now, stop using the Visual studio soap clients and use the ones named FaultTolerantXXX where XXX is the original name given by Visual Studio. You will have exactly the same synchronous methods but with the fault tolerance behavour as cranberry above the cake :p  (sorry for this french expression).

Additional steps

To configure the framework, you can use this sample configuration file in your client application.

The road map

The next steps will be :

  • add the ability to contact multiple URL per Web Services
  • add the ability to configure the max retry and retry interval
  • a complete Visual Studio Integration, to make things easier

So if you want to help, just download the code and send me patches !

]]> http://www.manitra.net/blog/dev/fault-tolerant-web-service-framework-implementation/feed/ 1 A great, open source, Visual Studio 2005/2008 Addin http://www.manitra.net/blog/dev/a-great-open-source-visual-studio-20052008-addin/ http://www.manitra.net/blog/dev/a-great-open-source-visual-studio-20052008-addin/#comments Thu, 20 Mar 2008 22:51:01 +0000 manitra http://www.manitra.net/blog/developpement/a-great-open-source-visual-studio-20052008-addin/ I’d like to give an introdution of a great and open source addin for Visual Studio 2005/2008. Its name is Koda and its main features are:

  • generate Constructos and properties from existing fields
  • fast type/file search
  • goto Test
  • Collapse all project
  • Close all documents

More features are comming soon !

If you don’t want to pay for addin like resharper this one is the best “free” alternative.

To make it short, here are the project info :

Name : Koda

Url : http://www.codeplex.com/koda

Cost : Free

Source : Open source, hosted by CodePlex

Language : C#

]]> http://www.manitra.net/blog/dev/a-great-open-source-visual-studio-20052008-addin/feed/ 1