File: src\Framework\MS\Internal\Globalization\BamlTreeUpdater.cs
Project: wpf\PresentationFramework.csproj (PresentationFramework)
using System;
using System.IO;
using System.Globalization;
using System.Runtime.InteropServices;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Text;
using System.Security.Permissions;
using System.ComponentModel;
using System.Xml;
using System.Windows;
using System.Windows.Markup;
using System.Windows.Markup.Localizer;
 
namespace MS.Internal.Globalization
{
    internal static class BamlTreeUpdater
    {
        //-----------------------------
        // internal methods
        //-----------------------------
        
        internal static void UpdateTree(
            BamlTree                    tree, 
            BamlTreeMap                 treeMap, 
            BamlLocalizationDictionary  dictionary
            )
        {    
 
            Debug.Assert(tree != null && tree.Root != null, "Empty Tree!");
            Debug.Assert(treeMap != null, "Empty map!");
            Debug.Assert(dictionary != null, "Empty dictionary");
 
            // no changes to do to the tree.
            if (dictionary.Count <= 0) 
                return;
 
            // create a tree map to be used for update
            BamlTreeUpdateMap updateMap = new BamlTreeUpdateMap(treeMap, tree);
 
            //
            // a) Create baml tree nodes for missing child place holders and properties.
            //    Translations may require new nodes to be constructed. For example
            //    translation contains new child place holders
            //
            CreateMissingBamlTreeNode(dictionary, updateMap);
            
            
            // 
            // b) Look through each translation and make modification to the tree
            //    At this step, new nodes are linked to the tree if applicable.
            //            
            BamlLocalizationDictionaryEnumerator enumerator = dictionary.GetEnumerator();
            ArrayList deferredResources = new ArrayList();            
            while (enumerator.MoveNext())
            {
                if (!ApplyChangeToBamlTree(enumerator.Key, enumerator.Value, updateMap))
                {
                    deferredResources.Add(enumerator.Entry);
                }
            }           
 
            //
            // c) Hook up the property nodes that aren't hooked up yet            
            //    Formatting tags inserted in the translation will only be created the 
            //    previous step. Hook up properties to those nodes now if applicable
            //
            for(int i = 0; i < deferredResources.Count; i++)
            {
                DictionaryEntry entry = (DictionaryEntry) deferredResources[i];
                ApplyChangeToBamlTree(
                    (BamlLocalizableResourceKey) entry.Key, 
                    (BamlLocalizableResource) entry.Value,
                    updateMap
                    );
            }
        }            
 
        private static void CreateMissingBamlTreeNode(
            BamlLocalizationDictionary dictionary,
            BamlTreeUpdateMap          treeMap
            )
        {
            BamlLocalizationDictionaryEnumerator enumerator = dictionary.GetEnumerator();
            while (enumerator.MoveNext())
            {
                BamlLocalizableResourceKey key   = enumerator.Key;
                BamlLocalizableResource resource = enumerator.Value;
 
                // get the baml tree node from the tree
                BamlTreeNode node = treeMap.MapKeyToBamlTreeNode(key);                
 
                if (node == null)
                {                    
                    if (key.PropertyName == BamlConst.ContentSuffix)
                    {                        
                        // see if there is already a Baml node with the Uid. If so
                        // ignore this entry
                        node = treeMap.MapUidToBamlTreeElementNode(key.Uid);
                        if (node == null)
                        {
                            // create new Baml element node
                            BamlStartElementNode newNode    = new BamlStartElementNode(
                                treeMap.Resolver.ResolveAssemblyFromClass(key.ClassName),
                                key.ClassName,
                                false, /*isInjected*/
                                false /*CreateUsingTypeConverter*/
                                );                        
                                
                            // create new x:Uid node for this element node
                            newNode.AddChild(
                                new BamlDefAttributeNode(
                                    XamlReaderHelper.DefinitionUid,
                                    key.Uid                                
                                    )
                                );
 
                            TryAddContentPropertyToNewElement(treeMap, newNode);
                            
                            // terminate the node with EndElementNode
                            newNode.AddChild(new BamlEndElementNode());
 
                            // store this new node into the map so that it can be found
                            // when other translations reference it as a childplace holder, or property owner
                            treeMap.AddBamlTreeNode(key.Uid, key, newNode);                            
                        }
                    }
                    else
                    {      
                        BamlTreeNode newNode;
                        if (key.PropertyName == BamlConst.LiteralContentSuffix)
                        {
                            // create a LiterContent node
                            newNode = new BamlLiteralContentNode(resource.Content);
                        }
                        else
                        {
                            newNode = new BamlPropertyNode(
                                treeMap.Resolver.ResolveAssemblyFromClass(key.ClassName), 
                                key.ClassName,
                                key.PropertyName,
                                resource.Content,
                                BamlAttributeUsage.Default
                                );                            
                        }                    
 
                        // add to the map
                        treeMap.AddBamlTreeNode(null, key, newNode);
                    }                
                }                
            }
            
        }
        
        private static bool ApplyChangeToBamlTree(
            BamlLocalizableResourceKey key, 
            BamlLocalizableResource    resource,
            BamlTreeUpdateMap          treeMap
            )
        {
            if (   resource == null 
                || resource.Content == null
                || !resource.Modifiable)             
            {
                // Invalid translation or the resource is marked as non-modifiable.
                return true;
            }            
 
            if (   !treeMap.LocalizationDictionary.Contains(key) 
                && !treeMap.IsNewBamlTreeNode(key))
            {
                // A localizable node is either in the localization dicationary extracted 
                // from the source or it is a new node created by the localizer. 
                // Otherwise, we cannot modify it.
                return true; 
            }            
 
            // get the node, at this point, all the missing nodes are created
            BamlTreeNode node = treeMap.MapKeyToBamlTreeNode(key);
            Invariant.Assert(node != null);
                        
            // apply translations
            switch (node.NodeType)
            {
                case BamlNodeType.LiteralContent :
                {
                    BamlLiteralContentNode literalNode = (BamlLiteralContentNode) node;
 
                    // set the content to the node.
                    literalNode.Content = BamlResourceContentUtil.UnescapeString(resource.Content);
 
                    // now try to link this node into the parent.
                    if (literalNode.Parent == null)
                    {
                        BamlTreeNode parent = treeMap.MapUidToBamlTreeElementNode(key.Uid);                            
                        if (parent != null)
                        {
                            // link it up with the parent
                            parent.AddChild(literalNode);
                        }  
                        else
                        {
                            return false; // can't resolve the parent yet
                        }
                    }
                    break;
                }
                case BamlNodeType.Property :                    
                {                
                    BamlPropertyNode propertyNode = (BamlPropertyNode) node;
 
                    // set the translation into the property 
                    propertyNode.Value = BamlResourceContentUtil.UnescapeString(resource.Content);
 
                    // now try to link this node into the parent
                    if (propertyNode.Parent == null)
                    {
                        BamlStartElementNode parent = (BamlStartElementNode) treeMap.MapUidToBamlTreeElementNode(key.Uid);                             
                        if (parent != null)
                        {
                            // insert property node to the parent
                            parent.InsertProperty(node);                               
                        }
                        else
                        {
                            return false;
                        }
                    }                                     
                    break;
                }
                case BamlNodeType.StartElement :
                {     
                    string source = null;
                    if (treeMap.LocalizationDictionary.Contains(key))
                    {                          
                        source = ((BamlLocalizableResource) treeMap.LocalizationDictionary[key]).Content;
                    }
 
                    if (resource.Content != source)
                    {
                        // only rearrange the value if source and update are different
                        ReArrangeChildren(key, node, resource.Content, treeMap);
                    }                        
                    
                    break; 
                }                    
                default :                       
                    break;
            }                 
                      
 
           return true;
        }
        
        private static void ReArrangeChildren(
            BamlLocalizableResourceKey  key,
            BamlTreeNode                node, 
            string                      translation,
            BamlTreeUpdateMap           treeMap
            )
        {
            //
            // Split the translation into a list of BamlNodes.
            //
            IList<BamlTreeNode> nodes = SplitXmlContent(
                key,
                translation,
                treeMap
                );
 
            // merge the nodes from translation with the source nodes
            MergeChildrenList(key, treeMap, node, nodes);            
        }
 
        private static void MergeChildrenList(
            BamlLocalizableResourceKey  key,    
            BamlTreeUpdateMap           treeMap,
            BamlTreeNode                parent,
            IList<BamlTreeNode>         newChildren
            )
        { 
            if (newChildren == null) return;
                
            List<BamlTreeNode> oldChildren = parent.Children;
 
            int nodeIndex = 0;
            StringBuilder textBuffer = new StringBuilder();                    
            if (oldChildren != null)
            {
                Hashtable uidSubstitutions = new Hashtable(newChildren.Count);
                foreach (BamlTreeNode node in newChildren)
                {
                    if (node.NodeType == BamlNodeType.StartElement)
                    {
                        BamlStartElementNode element = (BamlStartElementNode) node; 
 
                        // element's Uid can be null if it is a formatting tag.
                        if (element.Uid != null)
                        {   
                            if (uidSubstitutions.ContainsKey(element.Uid))
                            {
                                treeMap.Resolver.RaiseErrorNotifyEvent(
                                    new BamlLocalizerErrorNotifyEventArgs(
                                        key,
                                        BamlLocalizerError.DuplicateElement
                                        )
                                    );                                
                                return; // the substitution contains duplicate elements.                                
                            }
                            
                            uidSubstitutions[element.Uid] = null;  // stored in Hashtable
                        }
                    }
                }            
 
                parent.Children = null; // start re-adding child element to parent               
                
                // The last node is EndStartElement node and must remain to be at the end,
                // so it won't be rearranged.                            
                for (int i = 0; i < oldChildren.Count - 1; i++)
                {
                    BamlTreeNode child = oldChildren[i];
                    switch (child.NodeType)
                    {
                        case BamlNodeType.StartElement:
                        {
                            BamlStartElementNode element = (BamlStartElementNode) child; 
                            
                            if (element.Uid != null)
                            {   
                                if (!uidSubstitutions.ContainsKey(element.Uid))
                                {
                                    // cannot apply uid susbstitution because the susbstituition doesn't
                                    // contain all the existing uids. 
                                    parent.Children = oldChildren; // reset to old children and exit
                                    treeMap.Resolver.RaiseErrorNotifyEvent(
                                        new BamlLocalizerErrorNotifyEventArgs(
                                            key,
                                            BamlLocalizerError.MismatchedElements
                                            )
                                    );
                                    
                                    return;                                     
                                }
                                
                                // Each Uid can only appear once. 
                                uidSubstitutions.Remove(element.Uid);                                  
                            }
                        
                            // Append all the contents till the matching element.
                            while (nodeIndex < newChildren.Count)
                            {   
                                BamlTreeNode newNode = newChildren[nodeIndex++];
                                Invariant.Assert(newNode != null);                                                                
                                
                                if (newNode.NodeType == BamlNodeType.Text)
                                {
                                    textBuffer.Append(((BamlTextNode) newNode).Content); // Collect all text into the buffer                                   
                                }
                                else 
                                {
                                    TryFlushTextToBamlNode(parent, textBuffer);
                                    parent.AddChild(newNode);                  
                                    
                                    if (newNode.NodeType == BamlNodeType.StartElement)
                                        break;                                     
                                }                                                                
                            }
                            
                            break;
                        }
                        case BamlNodeType.Text:
                        {
                            // Skip original text node. New text node will be created from 
                            // text tokens in translation
                            break;
                        }
                        default:
                        {
                            parent.AddChild(child);
                            break;
                        }
                    }
                }
            }
 
            // finish the rest of the nodes
            for (; nodeIndex < newChildren.Count; nodeIndex++)
            {
                BamlTreeNode newNode = newChildren[nodeIndex];
                Invariant.Assert(newNode != null);                                                                
                
                if (newNode.NodeType == BamlNodeType.Text)
                {
                    textBuffer.Append(((BamlTextNode) newNode).Content); // Collect all text into the buffer                                   
                }
                else 
                {
                    TryFlushTextToBamlNode(parent, textBuffer);
                    parent.AddChild(newNode);                                      
                }                                                                
            }
 
            TryFlushTextToBamlNode(parent, textBuffer);
            
            // Always terminate the list with EndElementNode;
            parent.AddChild(new BamlEndElementNode());
        }
 
        private static void TryFlushTextToBamlNode(BamlTreeNode parent, StringBuilder textContent)
        {
            if (textContent.Length > 0)
            {
                BamlTreeNode textNode  = new BamlTextNode(textContent.ToString());
                parent.AddChild(textNode);
                textContent.Length = 0;
            }
        }
 
        private static IList<BamlTreeNode> SplitXmlContent(
            BamlLocalizableResourceKey  key, 
            string                      content, 
            BamlTreeUpdateMap           bamlTreeMap
            )
        {
            // process each translation as a piece of xml content because of potential formatting tag inside
            StringBuilder xmlContent = new StringBuilder();
            xmlContent.Append("<ROOT>");
            xmlContent.Append(content);
            xmlContent.Append("</ROOT>");
 
            IList<BamlTreeNode> list = new List<BamlTreeNode>(4);
            XmlDocument doc = new XmlDocument();
 
            bool succeed = true;
 
            try 
            {                
                doc.LoadXml(xmlContent.ToString());
                XmlElement root = doc.FirstChild as XmlElement;
                if (root != null && root.HasChildNodes)
                {
                    for (int i = 0; i < root.ChildNodes.Count && succeed; i++)
                    {                    
                        succeed = GetBamlTreeNodeFromXmlNode(
                            key,
                            root.ChildNodes[i],
                            bamlTreeMap,
                            list
                            );                             
                    }
                }                            
            }
            catch (XmlException)
            {
                // The content can't be parse as Xml.
                bamlTreeMap.Resolver.RaiseErrorNotifyEvent(
                    new BamlLocalizerErrorNotifyEventArgs(
                        key,
                        BamlLocalizerError.SubstitutionAsPlaintext
                        )
                );
 
                // Apply the substitution as plain text                                    
                succeed = GetBamlTreeNodeFromText(
                    key,
                    content,
                    bamlTreeMap,
                    list
                    );                       
            }           
 
            return (succeed ? list : null);
        }
        
        private static bool GetBamlTreeNodeFromXmlNode(
            BamlLocalizableResourceKey key,
            XmlNode                    node,                    // xml node to construct BamlTreeNode from
            BamlTreeUpdateMap          bamlTreeMap,             // Baml tree update map
            IList<BamlTreeNode>        newChildrenList          // list of new children
            )
        {
            if (node.NodeType == XmlNodeType.Text)
            {
                // construct a Text tree node from the xml content
                return GetBamlTreeNodeFromText(
                    key,
                    node.Value, 
                    bamlTreeMap,
                    newChildrenList
                    );
            }
            else if (node.NodeType == XmlNodeType.Element)
            {
                XmlElement child    = node as XmlElement;
                string className    = bamlTreeMap.Resolver.ResolveFormattingTagToClass(child.Name);
 
                bool invalidResult = string.IsNullOrEmpty(className);
 
                string assemblyName = null;
                if (!invalidResult)
                {
                    assemblyName = bamlTreeMap.Resolver.ResolveAssemblyFromClass(className);
                    invalidResult = string.IsNullOrEmpty(assemblyName);
                }                                    
 
                if (invalidResult)
                {
                    bamlTreeMap.Resolver.RaiseErrorNotifyEvent(
                        new BamlLocalizerErrorNotifyEventArgs(
                            key,
                            BamlLocalizerError.UnknownFormattingTag
                            )
                        );
                    return false;                        
                }
 
                // get the uid for this formatting tag
                string tagUid = null;
                if (child.HasAttributes)
                {
                    tagUid = child.GetAttribute(XamlReaderHelper.DefinitionUid);
 
                    if (!string.IsNullOrEmpty(tagUid))
                        tagUid = BamlResourceContentUtil.UnescapeString(tagUid);
                }                
 
 
                BamlStartElementNode bamlNode = null;                
                if (tagUid != null)
                {
                    bamlNode = bamlTreeMap.MapUidToBamlTreeElementNode(tagUid);
                }
 
                if (bamlNode == null)
                {
                    bamlNode = new BamlStartElementNode(
                        assemblyName,
                        className,
                        false, /*isInjected*/
                        false /*CreateUsingTypeConverter*/
                        );                        
 
                    if (tagUid != null)
                    {
                        // store the new node created                        
                        bamlTreeMap.AddBamlTreeNode(
                            tagUid,
                            new BamlLocalizableResourceKey(tagUid, className, BamlConst.ContentSuffix, assemblyName),
                            bamlNode
                            );
 
                        // Add the x:Uid node to the element
                        bamlNode.AddChild(
                            new BamlDefAttributeNode(
                                XamlReaderHelper.DefinitionUid,
                                tagUid
                                )
                        );
                    }
 
                    TryAddContentPropertyToNewElement(bamlTreeMap, bamlNode);
 
                    // terminate the child by a end element node
                    bamlNode.AddChild(new BamlEndElementNode());
                }
                else
                {
                    if (bamlNode.TypeFullName != className)
                    {
                        // This can happen if the localizer adds a new element with an id 
                        // that is also been added to the newer version of source baml
                        bamlTreeMap.Resolver.RaiseErrorNotifyEvent(
                            new BamlLocalizerErrorNotifyEventArgs(
                                key,
                                BamlLocalizerError.DuplicateUid
                                )
                            );
                        return false;
                    }
                }
 
                newChildrenList.Add(bamlNode);
 
                bool succeed = true; 
                if (child.HasChildNodes)
                {
                    // recursively go down 
                    IList<BamlTreeNode> list = new List<BamlTreeNode>();                    
                    for (int i = 0; i < child.ChildNodes.Count && succeed; i++)
                    {
                        succeed = GetBamlTreeNodeFromXmlNode(
                            key,
                            child.ChildNodes[i], 
                            bamlTreeMap, 
                            list
                            );                        
                    }
 
                    if (succeed)
                    {
                        // merging the formatting translation with exisiting nodes. 
                        // formatting translation doesn't contain properties.
                        MergeChildrenList(key, bamlTreeMap, bamlNode, list);
                    }
                }
 
                return succeed;
            }            
 
            return true; // other than text and element nodes
        }
 
        private static bool GetBamlTreeNodeFromText(
            BamlLocalizableResourceKey  key,
            string                      content,                 // xml node to construct BamlTreeNode from
            BamlTreeUpdateMap           bamlTreeMap,
            IList<BamlTreeNode>         newChildrenList          // list of new children
            )
        {
            BamlStringToken[] tokens = BamlResourceContentUtil.ParseChildPlaceholder(content);
 
            if (tokens == null)
            {
                bamlTreeMap.Resolver.RaiseErrorNotifyEvent(
                    new BamlLocalizerErrorNotifyEventArgs(
                        key,
                        BamlLocalizerError.IncompleteElementPlaceholder
                        )
                    );
                return false;
            }
 
            bool succeed = true;
            for (int i = 0; i < tokens.Length; i++)
            {
                switch (tokens[i].Type)
                {
                    case BamlStringToken.TokenType.Text :
                    {
                        BamlTreeNode node = new BamlTextNode(tokens[i].Value);
                        newChildrenList.Add(node);
                        break;
                    }
                    case BamlStringToken.TokenType.ChildPlaceHolder :
                    {
                        BamlTreeNode node = bamlTreeMap.MapUidToBamlTreeElementNode(tokens[i].Value);  
 
                        // The value will be null if there is no uid-matching node in the tree.                        
                        if (node != null) 
                        {
                            newChildrenList.Add(node);
                        }
                        else
                        {
                            bamlTreeMap.Resolver.RaiseErrorNotifyEvent(
                                new BamlLocalizerErrorNotifyEventArgs(
                                    new BamlLocalizableResourceKey(
                                        tokens[i].Value,
                                        string.Empty,
                                        string.Empty
                                        ),
                                    BamlLocalizerError.InvalidUid
                                    )
                                );   
                            succeed = false;                                
                        }
                        
                        break;
                    }   
                }
            }                        
            
            return succeed;
        }
 
        /// <remarks>
        /// Try to add the matching ContentPropertyNode to the newly constructed element
        /// </remarks>
        private static void TryAddContentPropertyToNewElement(
            BamlTreeUpdateMap bamlTreeMap, 
            BamlStartElementNode bamlNode
            )
        {
            string contentProperty = bamlTreeMap.GetContentProperty(bamlNode.AssemblyName, bamlNode.TypeFullName);
            if (!string.IsNullOrEmpty(contentProperty))
            {
                bamlNode.AddChild(
                    new BamlContentPropertyNode(
                        bamlNode.AssemblyName,
                        bamlNode.TypeFullName,
                        contentProperty
                        )
                    );
            }        
        }      
 
        private class BamlTreeUpdateMap
        {
            private BamlTreeMap _originalMap;
            private BamlTree    _tree;
 
            // from Uid to new nodes created, it is used when:
            // o Deserializing formatting tags e.g <b Id="bold01"></b>. It looks up the node by "bold01".
            // o Apply properties for new nodes. e.g. "Italic01:System.Windows.TextElement.Foreground" is applied on 
            //   element with "Italic 01".
            private Hashtable _uidToNewBamlNodeIndexMap;
 
            // from full key name to new nodes created
            private Hashtable _keyToNewBamlNodeIndexMap;
 
            // cached content property table storing (fulltypeName, content property name) pair. 
            private Dictionary<String, string> _contentPropertyTable;            
 
            internal BamlTreeUpdateMap(BamlTreeMap map, BamlTree tree)
            {
                _uidToNewBamlNodeIndexMap = new Hashtable(8);
                _keyToNewBamlNodeIndexMap = new Hashtable(8);
                _originalMap              = map;
                _tree                     = tree;
            }
 
            internal BamlTreeNode MapKeyToBamlTreeNode(BamlLocalizableResourceKey key)
            {
                BamlTreeNode node = _originalMap.MapKeyToBamlTreeNode(key, _tree);
 
                if (node == null)
                {   
                    // find it in the new nodes
                    if (_keyToNewBamlNodeIndexMap.Contains(key))
                    {
                        node = _tree[(int)_keyToNewBamlNodeIndexMap[key]];
                    }
                }
 
                return node;
            }
 
            internal bool IsNewBamlTreeNode(BamlLocalizableResourceKey key)
            {
                return _keyToNewBamlNodeIndexMap.Contains(key);    
            }
 
            internal BamlStartElementNode MapUidToBamlTreeElementNode(string uid)
            {
                BamlStartElementNode node = _originalMap.MapUidToBamlTreeElementNode(uid, _tree);
                if (node == null)
                {
                    // find it in the new nodes
                    if (_uidToNewBamlNodeIndexMap.Contains(uid))
                    {
                        node = _tree[(int)_uidToNewBamlNodeIndexMap[uid]] as BamlStartElementNode;
                    }
                }     
 
                return node;
            }                
            internal void AddBamlTreeNode(
                string                      uid,
                BamlLocalizableResourceKey  key,
                BamlTreeNode                node
                )
            {
                // add to node
                _tree.AddTreeNode(node);
 
                // remember the tree node index
                if (uid != null)
                {
                    _uidToNewBamlNodeIndexMap[uid] = _tree.Size - 1;
                }
 
                _keyToNewBamlNodeIndexMap[key] = _tree.Size - 1;
            }
 
            internal BamlLocalizationDictionary LocalizationDictionary
            {
                get { return _originalMap.LocalizationDictionary; }
            }
 
            internal InternalBamlLocalizabilityResolver Resolver
            {
                get { return _originalMap.Resolver; }
            }            
 
            /// <remarks>
            /// The method retrieves the Content property name for the given type. It first looks into 
            /// the KnownTypes table for the value. If not found, it will do a reflection to grab the 
            /// ContentPropertyAttribute on the type. Custom-control assembly is alrady required to be 
            /// present for BamlWriter to generate baml. 
            /// </remarks>
            internal string GetContentProperty(string assemblyName, string fullTypeName)
            {
                //
                // go to KnownTypes to find the content property first
                //
                string nameSpace = string.Empty;
                string typeName = fullTypeName;
                int lastDot = fullTypeName.LastIndexOf('.'); 
                if (lastDot >= 0)
                {
                    nameSpace = fullTypeName.Substring(0, lastDot);
                    typeName  = fullTypeName.Substring(lastDot + 1);
                }
 
                short id = BamlMapTable.GetKnownTypeIdFromName(assemblyName, nameSpace, typeName);
 
                if (id != 0)
                {
                    KnownElements knownElement = (KnownElements)(-id);
                    return KnownTypes.GetContentPropertyName(knownElement);
                }
 
                string contentProperty = null;
 
                //
                // Look into cached values.                 
                //
                if (_contentPropertyTable != null && _contentPropertyTable.TryGetValue(fullTypeName, out contentProperty))
                {
                    return contentProperty;
                }
 
                //
                // Need to do reflection for it. 
                //
                
                // Assembly.Load will throw exception if it fails. 
                Assembly assm = Assembly.Load(assemblyName);
                Type type = assm.GetType(fullTypeName);
                if (type != null)
                {
                    object[] contentPropertyAttributes = type.GetCustomAttributes(
                        typeof(ContentPropertyAttribute),
                        true                           // search for inherited value
                        );
 
                    if (contentPropertyAttributes.Length > 0)
                    {
                        ContentPropertyAttribute contentPropertyAttribute = contentPropertyAttributes[0] as ContentPropertyAttribute;
                        contentProperty = contentPropertyAttribute.Name;
 
                        // Cach the value for future use.
                        if (_contentPropertyTable == null)
                        {
                            _contentPropertyTable = new Dictionary<string, string>(8);                                
                        }
                        _contentPropertyTable.Add(fullTypeName, contentProperty);                            
                    }
                }
            
                return contentProperty;
            }            
            
        }        
    }     
 
    
}