After elaborating on the topic on my first post (see comments), it's time to wrap the all thing up. As I've noted, the purpose was to brought up some points of interest about developing classes which wrap unmanaged code inside them. When I'm reviewing my teammates code, any usage of unmanaged code triggers me as I start thinking about all the scenarios of which the unmanaged code stays un-handled and therefore causes memory leaks in the application. One of the scenarios which can cause a memory leak was the one we've talked about(again, the code in the first post was only for teaching purpose, so this post will be more relevant), but this could be better handled by implementing "Dispose pattern" on the (wrapper)class.

Consider the following code:

* Note: this code was written for teaching purpose only and is highly not recommended in "real world" implementation.

public class CustomWriter : IDisposable
{
   private StreamWriter m_sw;

   public CustomWriter(string filePath, int numberOfLinesToWrite)
   {
      m_sw = new StreamWriter(filePath);

      if (numberOfLinesToWrite < 0)
      {
         throw new ArgumentException("What's wrong with you ?!!? numberOfLinesToWrite can't be less than 0", "numberOfLinesToWrite");
      }

      // Assume that I'm using numberOfLinesToWrite here...
   }

   #region IDisposable Members

   public void Dispose()
   {
      // Time to say goodbye
      m_sw.Close();
   }

   #endregion
}

And now, here is a simple runner:

using (CustomWriter cw = new CustomWriter(@"c:\oren.txt", 15))
{
   // some code here...
}

This one works as expected and the StreamWriter is being cleaned as using calls the Dispose method.

But what happens if the path is invalid like "c:oren.txt" or maybe "c:\windows\system32\cdosys.dll" ??
Nothing much to tell the truth as the resource(StreamWriter) will die and fail to initalize - we're OK.

But what about this scenario:

using (CustomWriter cw = new CustomWriter(@"c:\oren.txt", -5)) // <-- Remember? "-5" is invalid argument
{
   // some code here...
}

Now we're in trouble: The Dispose method is NOT called at all and the resource is running free on the memory street with no GC(garbage collector) police to hold him back (a little metaphor, why not?). Need I to say how BAD this case is ?!

 

To sum it all up: constructors should NEVER throw any kind of exception. If you have a case which you need to do some extra initialization that could throw an exception in certain cases - do it in a method inside the class (Initialize() sounds right).

* I'd like to give the deserved credit for Amir Engel(His blog is on its way, hold tight) for elaborating on the subject with me

A dear friend of mine, Shani, wrote a great post about the subject which I highly recommand; Pay him a visit.

I've written a method which will format any given string into a more readable phrase. This method can be quite useful if you're generating your code or building your API based on an outer settings like a config file, DB, Reflection etc. Here is the code...

A must read, IMO, article about xml parsing:

http://support.softartisans.com/kbview.aspx?ID=673

This will give you some insights about the options available for you via .Net framework for parsing\manipulating xml data.

This post is mostly a self reminder but it may come useful if you're using CodeSmith as well.
It is possible to check if a (schema)column is an identity field via ExtendedProperties property of the SchemaObjectBase class:

// Only for Sql Server
private bool IsIdentityColumn(ColumnSchema column)
{
   return (bool)column.ExtendedProperties["CS_IsIdentity"].Value;
}

There is one exception though and that's if you're sending the column object through the TableSchema.ForeignKey[index].ForeignKeyMemberColumns or TableSchema.ForeignKeys[index].PrimaryKeyMemberColumns, meaning:

for(int i=0; i<MySourceTable.ForeignKeys.Count; i++)
{
   // Same thing about MySourceTable.ForeignKeys[i].PrimaryKeyMemberColumns...
   for (int j=0; j<MySourceTable.ForeignKeys[i].ForeignKeyMemberColumns.Count; j++)
   {
      if (IsIdentityColumn(MySourceTable.ForeignKeys[i].ForeignKeyMemberColumns[j])) // <-- Exception Here.
      {
         //do some code         
      }
   }   
}

The extended properties will NOT hold the key "CS_IsIdentity" and IsIdentityColumn will throw an exception (null reference). I'm still not sure if this is by design or not, so I'll try to fish it out on from the net and update the post later on. 

The solution is simply working a little harder via TableSchema.Keys and than verify the type of the key (by PrimaryKeyTable and ForeignKeyTable properties).

update:
This is quite a dirty hack, but it works and I'm loving it (I don't have to change a lot of code in a lot of different places) !  
I refactor the mehotd IsIdentityColumn so it will do the trick:

private bool IsIdentityColumn(ColumnSchema column)
{
   if (column.ExtendedProperties["CS_IsIdentity"] == null)
      column = column.Table.Columns[column.Name];

   return (bool)column.ExtendedProperties["CS_IsIdentity"].Value;
}

Back to code...

Do I need to call base.METHOD after overriding it, and if so - when is it the right time ?

Well, I'm glad you've asked; I had some chat with my co-worker about the subject when he did some overriding to the Form (WinForm) methods and he wasn't sure about when is it smart to call the base method and if so, should he call base.METHOD before implementing his code, or maybe after. To clarify, quick example:

public class MyForm : Form
{
   protected override void OnLoad(EventArgs e)
   {
      //OK, what here ???!!

      // Custom code here ?
      //base.OnLoad(e); // should I ?
      // Or maybe - Custom code here... ?
   }
}

After thinking for a few seconds, I came up with this explanation - sort of my "best practice" to the issue:

When do I call base.METHOD:

1. If you don't know the implementation in the method you've just override: assume that it does some "magic" stuff which is important to the correct flow of the application; But This doesn't mean that you must call the base method.
   • If you want to stop the logic flow, it makes sense to override the appropriate method and write your code which will change the flow according to your need. In this scenario there is no need to call the base method.
   • If you don't want to change the logic flow, or you're not sure - call the base method.
2. If you know the implementation in the method you've just override: no "magic" stuff so this is an easy call - if you need the code in the base method, call it - otherwise - leave it out.

Do I call base.METHOD after my custom code, or maybe before:

This is a tricky one and there is not straight answer - my way of thinking and tackling this question is simply by Explore, Run & Learn "process" - meaning, try to Explore about the base method original purpose and try to figure out the logic; This will give you some logical direction whether you need to call the base method or not. For example - if you override the Render method, you can tell (by MSDN or by Reflector) that its rendering the entire object graph so you probably should call it (eventually). Now that you have some feeling about whether you need to write your code before or after the base.METHOD call, Run it and exam the results:

• Does the page behaves as you expected?
• Can you mess it up so it won't work in some scenarios - how can you deal with it ?
• Grab the nearest programmer available, can he think about something which will mess it up ? if so - how can you deal with it ?

According to the results and the answers about the given questions, you should now have a clear vision about your decision. Make the required adjustments, place some important remarks(to describe your thinking at the moment) and feel good about your code, you did your best to get a good result. And most important - Learn from the process so it will be more natural on the next time you'll have to face this decision.

I love the new generics in .Net 2.0; Combining it with abstract classes and I could almost throw my interfaces to the garbage collection of life (coming soon...).
There is one scenario though that I can't seem to figure out the solution with a generic type, and that's the is keyword. The problem is that you can't ask the object if it is from GenericClass<T> type, assuming you don't care about the T object. You can't even ask if it is from GenericClass<BaseClass> (where T : BaseClass) in case that T is inherits from BaseClass. The only way to get "true" from this phrase it is to ask for the specific T used in the GenericClass, which is most of the time unknown. I know, I know, this is Chinese at the first read, so here is an example and than you'll have to go Memento(the movie) on this post and roll back to the beginning of the post to understand my point:

public class EntityCollection<T> : List<T>
   where T : EntityBase
{
   public virtual string GetXml()
   {
      StringBuilder output = new StringBuilder(Count * 100);

      output.Append("<" + typeof(T).Name + "List" + ">"); 

      // Build the inner xml for every "T" object.
      this.ForEach(delegate(T t) { output.Append(t.GetXml()); });

      output.Append("</" + typeof(T).Name + "List" + ">"); 

      return output.ToString();
   }
}

public abstract class EntityBase
{
   public virtual string GetXml()
   {
      StringBuilder output = new StringBuilder(100);
      Type currentType = this.GetType();

      output.Append("<" + currentType.Name + ">");

      // --
      // Use reflection to build the properties xml on the fly.
      PropertyInfo[] props = currentType.GetProperties();
      foreach (PropertyInfo prop in props)
      {
         object propertyValue = prop.GetValue(this, null);
         string text = "";
         if (propertyValue != null)
         {
            // ****
            // DON'T WORK:
            // propertyValue will never be from EntityCollection<EntityBase> though it will contain EntityCollection<Item>
            // and Item inherits from EntityBase. This is logically right of course, BUT I still need a workaround.
            if (propertyValue is EntityCollection<EntityBase>) // <-- The problem is here!
            {
               text = ((EntityCollection<EntityBase>)propertyValue).GetXml();
            }
            else if (propertyValue is EntityBase)
            {
               text = ((EntityBase)propertyValue).GetXml();
            }
            else
            {
               text = "<![CDATA[" + propertyValue.ToString() + "]]>";
            }
            // ****
         }

         output.Append("<" + prop.Name + ">");
         output.Append(text);
         output.Append("</" + prop.Name + ">");
      }
      // --

      output.Append("</" + currentType.Name + ">");

      return output.ToString();
   }
}

public class Order : EntityBase
{
   private int m_orderID;
   private EntityCollection<Item> m_orderItems;

   public Order(int orderID)
   {
      m_orderID = orderID;
      m_orderItems = new EntityCollection<Item>();
   }

   public EntityCollection<Item> OrderItems
   {
      get { return m_orderItems; }
      set { m_orderItems = value; }
   }
}

public class Item : EntityBase
{
   private int m_id;
   private string m_name;

   public int ID
   { 
      get { return m_id; }
      set { m_id = value; }
   }

   public string Name
   {
      get { return m_name; }
      set { m_name = value; }
   }

   public Item(int id, string name)
   {
      m_id = id;
      m_name = name;
   }    
}

And here is a simple tester:

static void Main(string[] args)
{
   Order o = new Order(1);
   o.OrderItems.Add(new Item(1, ".Net 2.0 book"));
   o.OrderItems.Add(new Item(2, "yet another .Net 2.0 book"));

   string oXml = o.GetXml();
}

The only solution I found to this problem is to implement an interface and inherit from it in my generic class and than use the is keyword on my interface instead of on the GenericClass<T>, i.e:

1. Create IXml interface which hold the GetXml method signature.
2. The EntityBase & EntityCollection class implement the IXml interface.
3. The EntityBase.Getxml() method check if propertyValue is IXml and if so - call ((IXml)propertyValue).GetXml();

After talking with some folks about it, I did some refactoring to the structure.

Just to remind you my purpose:

1. I want to validate the data before sending it to the DB(performance stuff), or at least at some level:

• For "string" fields - check for their length (by DB definition).
• For not nullable fields - check that they aren't null, depending on the required action (Insert, Update, Delete)

The actions I took:

In the ideal world, the entity would know how to validate it self, from A to Z, but the problem is that the validations change according to the required action(Insert, Delete, Update) and I don't want to couple my entity with my DAL.
I decided to split the "validation" checking in two - some of it in my Entities layer and the other some, in my Data-Access layer.

1. Entities layer:
   • In every set of the property(if the property is from string type, of course) -> validate the length of the property.
2. Data-Access layer:
   • Insert action:
     • Check that all the not nullable fields aren't nullable, unless the column is an Identity(auto-increment) field.
   • Update action:
     • If the field has to be updated (its status is "dirty", meaning, the programmer wants to update it) -> check for his "null condition" (all rights for this phrase are reserved for me, Oren Ellenbogen Inc.).
     • Check that all the primary key columns are not null.
   • Delete action:
     • Check that all the primary key columns are not null.

I like to handle my .cst(CodeSmith templates files) files with my VS.NET for it's integration with Visual Source Safe.
Well, no need for VSTweaks in this version of Visual Studio, The trick is quite simple:

1. Open you Visual Studio .Net 2005.
2. Tools -> Options -> Text Editor -> File Extension
3. In the "Extension" text-box write ".cst" and in the "Editor" drop-down-list select "Html Editor".

Wow, it's been a long time since I've published my latest post hasn't it ?
Ok, no time for lame "I was busy" excuses so let me fill the gaps -

1. New position:
   I got a promotion at work and now I'm a team leader at our R&D department. I've come across, in my 6 years at the business, several great people; Some of them were good because of their technical knowledge, some for their leadership capabilities, some for their good nature and some for combining all the above. I'm working my ass of to affect my teammates and the rest of the people in my company as much as the latter ones affected me in the previous six years.
2. Interviewing candidates:
   We are hiring; Myself and Roee(our technical manager) were interviewing about 50(some of them didn't pass my "phone exam") people in the previous 2 months. It required me to think about "what developers should know" and even more important "what developers should know how to find". In addition, it gave me a great look at the people in "my world" (not a perfect one, but still...)
3. New co-workers:
   We hired a team leader named Ken Egozi and a programmer named Tamir Kanhe – GOOD LUCK folks!
4. New challenges:
   I'm now figuring out the "Smart Client" architecture which we want to use in our application, this includes understanding:
   1. Composite UI Application Block
   2. ClickOnce
   3. Windows Forms 2.0 best practices(data binding, Async work, web services & WSE 3.0 etc).
      The world of windows forms is new to me so I have a lot to catch up.

Reading Dror's post, I had to give it a shot so -

If you want to see your extension - look here.

Well, Richard explains it better than me, so just read his post.

update: for some reason the link doesn't work well, so here is the full address:

http://blog.hundhausen.com/Database+Concordance+Generator+CodeSmith+Style.aspx

Just copy it and put it in the address bar, sorry for the inconvenience.

I've sold my laptop(Compaq EVO N800V) today. After almost 3 years with me I had to let him go (tears are dropping on my keyboard). I'm kidding(!), I'm planing to buy a new (monster-one)laptop next week so I had to get rid of my old one somehow. Dror advised me to publish a message at Homeless and his tip was gold (worth 2000 NIS, in this case).

I really recommend this site, I got more than 10 calls today, just an hour after I've published to post there. Let me see, I've published the post around 11:00 and I've sold it at 15:00 (someone came to see it and took it away).

AMAZING!