Collection of XmlNode control I have implemented the structure below at least 5 times, and it is getting cumbersome.  Is there a better approach?
Current code-segment implemented
public XmlNodeList Templates {
  get {
    return this.GetElementsByTagName( &quot;Templates&quot; );
  }
  set {
    foreach( UITemplateAssoc nd in value ) {
      this.AddTemplate( nd );
    }
  }
}
public UITemplateAssoc GetTemplate (string name) {
  foreach( UITemplateAssoc nd in this.Templates ) {
    if( nd.Name == name ) {
      return nd;
    }
  }

  return null;
}
public void AddTemplate ( UITemplateAssoc val ) {
  for( int i = this.Templates.Count - 1 ; i &gt;= 0 ; i-- ) {
    if( this.Templates[i].Name == val.Name ) {
      this.ReplaceChild( val , this.Templates[i] );
      return;
    }
  }

  this.AppendChild( val );
}
There's a couple of nice alternatives for you.

Extensions

If you don't need to encapsulate the XmlNodeList instances, you could make your methods extensions for XmlDocument or whatever you've extended:

public static class TemplateExtensions
{
    public static XmlNodeList GetTemplates(this XmlDocument document) 
    {
        return document.GetElementsByTagName("Templates");
    }

    public static UITemplateAssoc GetTemplate(this XmlNodeList list, string name)
    {
        foreach(var nd in list)
        {
            if (nd.Name == name) return nd;
        }
    }

    // ...
}

// ...
var templates = yourDocument.GetTemplates();
var template = templates.GetTemplate("abc");


More on extensions methods here: 
http://msdn.microsoft.com/en-us/library/bb383977.aspx

Inheritance

Put these methods in a base class and have the behavior that differs in inherited classes.

[edit]Updated to show how the base class can be generic[/edit]

public abstract class TemplateListBase&lt;T&gt;
    where T : XmlNode
{
    private XmlNodeList templates;

    public XmlNodeList Templates 
    {       
        get 
        {       
            return templates.GetElementsByTagName( "Templates" );       
        }       
    }       

    protected TemplateListBase(XmlNodeList initialList)
    {
        templates = initialList;
    }

    public void AddRange(XmlNodeList list) 
    {       
        foreach( T nd in list ) 
        {       
            AddTemplate( nd );       
        }       
    }

    public T GetTemplate (string name) 
    {       
        foreach( T nd in templates ) 
        {       
            if( nd.Name == name ) return nd;       
        }
        return null;
    }       

    public void AddTemplate ( T val ) 
    {       
        for( int i = templates.Count - 1 ; i &gt;= 0 ; i-- ) 
        {       
            if( templates[i].Name == val.Name ) 
            {       
                templates.ReplaceChild( val , templates[i] );       
                return;       
            }       
        }       
        templates.AppendChild( val );       
    }      
}

public class UITemplateAssocList : TemplateListBase&lt;UITemplateAssoc&gt;
{
    public UITemplateAssocList(XmlNodeList listOfUITemplates)
        : base(listOfUITemplates)
    {
    }

    public void FancyLogicA(string data)
    {
        foreach(var node in Templates)
        {
            // differing logic
        }
    }
}

public class ConcreteTemplateB : TemplateListBase&lt;SomeOtherKindOfNode&gt;
{
    // ..

    public void FancyLogicB(XmlNodeList list)
    {
        for (var node in list)
        {
            if (LikeThisNode(node)) AddTemplate(node);
        }
    }
}


Notice that I replaced your setter with an AddRange method.
It's ususally good practice not to replace an entire encapsulated collection using a setter. 
Although you can validate the entries in the setter, a property should not do much logic other than returning or setting privates.
If you have a look at the collections in the BCL, they all expose an AddRange method and a method Clear to empty the collection. The AddRange method also gives you the option of adding multiple sets in turn.

If you need different logic when stuff is added etc, have a look at the template method pattern:
http://en.wikipedia.org/wiki/Template_method_pattern

If you need multiple base classes with differing logic, you could combine the inheritance with the extension methods, or another base class. :)