For example, our app has a button control on the page, the xaml code looks something like:

<Button x:Name="MyButton" Content="My Sample Button" />

We want to assign one of the button properties with resource we load externally. Following are steps to create the separate xaml resource file and use the resources in the app:

1. Create an empty xaml file (i.e. let's name it MyResources.xaml) and add it to the Silverlight project
2. Change the Build Action property of the file from "None" or "Page" to "Content"
3. Put the resource dictionary definition in the xaml file, for example:

<ResourceDictionary

    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"

    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml">

    <SolidColorBrush x:Name="RedColorBrush"

                     Color="Red"

                     />

</ResourceDictionary>

Then add following code to load the resource dictionary and use the brush object on the existing button:

            // Read resources.xaml included in the project

            string xaml = null;

            StreamResourceInfo sri = Application.GetResourceStream(new Uri("MyResources.xaml", UriKind.Relative));

            using (StreamReader reader = new StreamReader(sri.Stream))

            {

                xaml = reader.ReadToEnd();

            }

            // Load the resource dictionary and access the resource using key

            if (xaml != null)

            {

                _globalResources = (ResourceDictionary)XamlReader.Load(xaml);

                // Now we can use the resource defined in the dictionary

                SolidColorBrush redColorBrush = (SolidColorBrush) _globalResources ["RedColorBrush"];

                MyButton.Background = redColorBrush;

            }

            ScriptObjectCollection soc = HtmlPage.Document.GetElementsByTagName("Title");

            if (soc != null && soc.Count > 0)

            {

                HtmlElement titleElement = (HtmlElement)soc[0];

                string title = (string)titleElement.GetProperty("innerHTML");

                // the code below will give me runtime error

                titleElement.SetProperty("innerHTML", title + " :-)");

            } 

Basically the code logic is to get the reference to <TITLE> element, and then get the inner html text and set it with new value. I wonder why I could not set the innerHTML property of the element even though I could get the html page title using the same property. I posted my question to our Silverlight internal forum, and learned that the innerHTML property is read-only for <TITLE> element (and some other elements which is actually documented here), and the MSDN documentation also mentions that we can change the value of <TITLE> element by assigning document.title properly. Therefore, my code above needs to be changed to:

            ScriptObjectCollection soc = HtmlPage.Document.GetElementsByTagName("Title");

            if (soc != null && soc.Count > 0)

            {

                HtmlElement titleElement = (HtmlElement)soc[0];

                string title = (string)titleElement.GetProperty("innerHTML");

                HtmlPage.Document.SetProperty("title", title + " :-)");

            }

It works perfectly now (the page title changes). I hope this helps in case you run into the same problem.

    public delegate void DataChangedDelegate(int oldValue, int newValue);

    class Foo

    {

        public DataChangedDelegate OnDataChanged = null;

        private int _data = 0;

        public int Data

        {

            get { return _data; }

            set { UpdateData(value); }

        }

        private void UpdateData(int updatedData)

        {

            if (OnDataChanged != null)

            {

                OnDataChanged(_data, updatedData);

            }

            _data = updatedData;

        }

    }

We can then create an instance of Foo class, and hook up the event handler to its public delegate as shown below.

     class Program

    {

        static void Main(string[] args)

        {

            Foo foo = new Foo();

            foo.OnDataChanged += OnDataChanged;

            foo.Data = 2;

            Console.WriteLine();

        }

        static void OnDataChanged(int oldValue, int newValue)

        {

            Console.WriteLine("Data changes from " + oldValue + " to " + newValue);

        }

    }

C# 3.0 or .NET 3.5 has new feature that provides us a set of generic delegates with the name "Action" or "Func", the difference between them is Action does not have return type (void), while Func has return type (refer to MSDN documentation). So from example above we can remove following code:

    public delegate void DataChangedDelegate(int oldValue, int newValue);

and replace following code: 

        public DataChangedDelegate OnDataChanged = null;

with:

        public Action<int, int> OnDataChanged = null; 

If the delegate returns bool data type for example, then we can use Func function such as:

        public Func<int, int, bool> OnDataChanged = null;

Although this new feature allows us not to declare the delegate types (means less line of code), but we may use our judgement whether to use it or not. The reason is because sometimes we may prefer to name the delegate type to make us better understand the code. Another thing is we can't use the delegate type we created interchangeably with its counterpart generic delegates unfortunately even though they have same signature (and not with explicit conversion either). For example, the following code below will not work.

            DataChangedDelegate dataChanged;

            Action<int, int> genericFunc;

            dataChanged = genericFunc;      // compile error 

Innovation: Don't innovate, but solve problems instead. By focusing on problem solving rather than creation of unique things, we will increase our odds of success in the pursuit of innovation. Become a problem solver, and not an innovator!

Failure: When things go wrong (as they will, or we didn't try hard enough), stop and ask why. Later when things go right (as they will), also ask where did the idea come from? What were we doing prior to having the big idea? Keep track of why and what led to these ideas, write them down and study this information trail. We will begin to observe a pattern beyond the happy accident.

Success: Although failure reduces the number of possible solutions, success ends the search for a solution, and ironically once the journey ends, curiosity is often shelved as the new idea moves into the generally accepted category of great ideas. Success begets a new set of rules that blinds us to new opportunities. Sustainable success is not a destination, but it is an aspiration (think it more as a process than a place).