April 2012 - Abu Ashraf Masnun

Say, we have a class defined in one of the assemblies shipped with a third party solution. It would be a great help if you could add a helper method to one of the objects. Unfortunately, we do not have the source code. 🙁 What do we do?

In such scenarios, .NET hasn’t left us alone in the desert 😀 The method extension technique will allow us to add our own methods to classes of our choice. Want to see an example? Take the List generics, every list of a generic type has some handy methods. Now we want to add one of ours. Printing each of the element in a list requires us to setup a foreach() loop every time. Why don’t we add an extension method named “Print()” which would print all the elements in a list – one by one? Let’s get our hands dirty!

Facts to remember:
— To extend a class and add method, we must declare a public static class with some name. The name doesn’t matter at all.
— We should define a method with our desired name in that class.
— The first parameter to the method will be “this < Object_we_want_to_extend > parameterName”. Do not forget the “this” keyword. It is the magic wand that does the magic.
— We can pass additional parameters.
— When calling the extended method from the original object, the first parameter is not required to pass. You can ignore it as if it were never there.
— For safety and security the extended method can not access private areas (fields, properties or methods).

So what do all these mean? Show me some codes! Okay, here you go:

using System;
using System.Collections.Generic;
using System.Linq;


namespace Test
{
    class Program
    {
        public static void Main(string[] args)
        {
            // Construct a list of "object" type. Setting the generic type to <object> will help us add all sorts of objects.
            List<object> list = new List<object>();

            // Add a string, integer and hell yeah - another list of string :D
            list.Add("masnun");
            list.Add(23);
            list.Add(new List<string>());

            // Lets call our extended method
            list.Print();

            // Halt the output until an enter is pressed. For a better examination of the output.
            Console.ReadLine();

        }
    }


    //The public static class with any name you choose
    public static class ListExtension
    {
        // The method name is Print. We're extending a generic here, so make the method follow.
        public static void Print<T>(this List<T> passedList)
        {
            // We loop through the generic and print the output of ToString()
            foreach (T x in passedList)
            {
                Console.WriteLine(x.ToString());
            }

        }
    }
}

using System;

using System.Collections.Generic;

using System.Linq;

namespace Test

{

class Program

{

public static void Main(string[] args)

{

// Construct a list of "object" type. Setting the generic type to <object> will help us add all sorts of objects.

List<object> list = new List<object>();

// Add a string, integer and hell yeah - another list of string :D

list.Add("masnun");

list.Add(23);

list.Add(new List<string>());

// Lets call our extended method

list.Print();

// Halt the output until an enter is pressed. For a better examination of the output.

Console.ReadLine();

}

//The public static class with any name you choose

public static class ListExtension

{

// The method name is Print. We're extending a generic here, so make the method follow.

public static void Print<T>(this List<T> passedList)

{

// We loop through the generic and print the output of ToString()

foreach (T x in passedList)

{

Console.WriteLine(x.ToString());

}

The output shall be:

masnun
23
System.Collections.Generic.List`1[System.String]

masnun

System.Collections.Generic.List`1[System.String]

Cool, no? 😀 The code is commented as much as I thought necessary. Feel free to ask a question or submit any feedback you might come up with 🙂

Have fun implementing some extended methods on your own 🙂

I have been reading about data binding in windows phone 7 development and got curious about how .net implements the observer pattern. I spent some time understanding the flow and decided to write a blog post about it.

.NET platform offers IObserver and IObservable interfaces to quickly get up and running with the observer pattern. We know the theory – there is an independent subject, a observable aimed towards monitoring that subject and some observers which are very keen to receive updates whenever something interesting happens to the subject. The observers know that the observable monitors the subject, so they subscribe to the observable for notifications. The observable accepts all these subscriptions, keeps them in a safe place. Then he keeps watching and watching. When something interesting happens to the subject, he quickly gets to the list of subscribers and then notifies them one by one.

Compare this scenario to the day before Eid Ul Fitr. Tomorrow is Eid if we see the moon. Now, you have decided to go to the roof and keep waiting there until the moon pops up. Knowing this, some of your friends (who are so computer freak that they don’t even want to leave their PCs to watch the moon of Eid Ul Fitr) called you and asked you to notify them if you see the moon.

Here:
The Moon == Subject
You == Observable
Your nerd friends == Observers

Here the observable keeps watching for the subject, when the subject pops up in the sky, the observable calls the observers – that’s it, simply that’s the observer pattern.

To implement this pattern, we define a Subject object. It has a counter. Every time you view the counter, it gets increased by one. We are doing this little magic to track any changes in the subject.

Then we define the SubjectObservable object which implements the IObservable. It accepts a subject in it’s constructor. This is not mandatory but we did this to track the subject in a better fashion. It provides a Subscribe() method which is called by the observers to subscribe to the observers. The method must return an IDisposable object. We do a trick and create a custom object implementing the IDisposable interface. In the constructor we accept the list of observers recorded by the observable and the instance of the observer passed for subscription. In the Dispose() method we remove the observer from the observer list. So when the Dispose() method of the disposer is called, the observer is removed from the observer list. The observable will no longer send any notifications to the removed observer.

The SubjectObserver is pretty simple. It has OnNext(), OnCompleted() and OnError() methods. The OnNext() is called by the observable to send the current state of the subject. Besides the abstract methods, we also define a constructor to accept a unique name instance and an instance of an observable to follow. When the OnNext() is called, we print out the current counter value of the subject. We also define a Dispose() method which shall invoke the Dispose() method of the disposer, removing itself from the observer list of the observable.

Well, if all these theories seem too complex to you. Do read the codes below. I have tried to add relevant comments. If you have any feedback, please do make a comment.

using System;
using System.Collections.Generic;
using System.Linq;


namespace Test
{
    class Program
    {
        public static void Main(string[] args)
        {
            // Create a subject and the observable, inject the subject into the observable
            Subject subject = new Subject();
            SubjectObservable observable = new SubjectObservable(subject);

            //Create two observers
            SubjectObserver zeus = new SubjectObserver(observable, "Zeus");
            SubjectObserver ares = new SubjectObserver(observable, "Ares");
            
            // Run a loop and trigger the observer
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("Counter: " + subject.Counter);
                observable.inspectSubject();

            }

            Console.ReadLine();
        }
    }

    //
    // Class Subject - It has a counter object that increases everytime you inspect it
    //

    class Subject
    {
        private int _counter;
        public int Counter
        {
            get
            {
                return ++_counter;
            }
        }

    }

    //
    // Class Subject Observable - The observable object that observes the subject and notifies the observers
    //

    class SubjectObservable : IObservable<Subject>
    {
        // List of observers and the instance of subject
        private List<IObserver<Subject>> _subjectObservers;
        private Subject _subject;

        // Accept a subject instance which we shall observe
        public SubjectObservable(Subject subject)
        {
            _subjectObservers = new List<IObserver<Subject>>();
            _subject = subject;

        }

        // This method allows the observers to attach themselves. It returns a disposer object to the observer
        // which the observer can utilize to unsubscribe
        public IDisposable Subscribe(IObserver<Subject> observer)
        {
            if (!_subjectObservers.Contains(observer))
            {
                _subjectObservers.Add(observer);
            }

            return new Disposer(_subjectObservers, observer);
        }

        // This method is used to inspect the subject over time. Usually used with a timer or an event
        public void inspectSubject()
        {
            foreach (IObserver<Subject> observer in _subjectObservers)
            {
                observer.OnNext(_subject);
            }
        }

        //
        // Private class Disposer: Implements the IDisposable. Observable returns an instance to the observer for easy unsubscription
        //
        private class Disposer : IDisposable
        {
            // The observers list recieved from the observable
            private List<IObserver<Subject>> _subjectObservers;
            // The observer instance to unsubscribe
            private IObserver<Subject> _observer;

            public Disposer(List<IObserver<Subject>> _subObservers, IObserver<Subject> observer)
            {
                _subjectObservers = _subObservers;
                _observer = observer;
            }

            public void Dispose()
            {
                if (_subjectObservers.Contains(_observer))
                {
                    _subjectObservers.Remove(_observer);
                }
            }
        }
    }

    //
    // Class Subject Observer - The object that attaches itself to a observable and recieves notifications
    //

    class SubjectObserver : IObserver<Subject>
    {
        // The disposer returned by the observable when subscribing
        private IDisposable _disposer;

        // Unique instance name to track the observer
        private string _instaceName;

        public SubjectObserver(IObservable<Subject> provider, string instanceName)
        {
            if (provider != null)
            {
                _disposer = provider.Subscribe(this);
                _instaceName = instanceName;
            }
        }

        // The observable invokes this method to pass the Subject object to the observer
        public void OnNext(Subject value)
        {
            Console.WriteLine("[" + _instaceName + "] " + value.Counter);
        }

        // Usually called when a transmission is complete. Not implemented.
        public void OnCompleted()
        {
            throw new NotImplementedException();
        }

        // Usually called when there was an error. Didn't implement.
        public void OnError(Exception error)
        {
            throw new NotImplementedException();
        }

        // Invoke the disposer recieved from the observable. This will unsubscribe
        public void Dispose()
        {
            _disposer.Dispose();
        }
    }

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

using System;

using System.Collections.Generic;

using System.Linq;

namespace Test

{

class Program

{

public static void Main(string[] args)

{

// Create a subject and the observable, inject the subject into the observable

Subject subject = new Subject();

SubjectObservable observable = new SubjectObservable(subject);

//Create two observers

SubjectObserver zeus = new SubjectObserver(observable, "Zeus");

SubjectObserver ares = new SubjectObserver(observable, "Ares");

// Run a loop and trigger the observer

for (int i = 0; i < 5; i++)

{

Console.WriteLine("Counter: " + subject.Counter);

observable.inspectSubject();

}

Console.ReadLine();

}

// Class Subject - It has a counter object that increases everytime you inspect it

class Subject

{

private int _counter;

public int Counter

{

get

{

return ++_counter;

}

// Class Subject Observable - The observable object that observes the subject and notifies the observers

class SubjectObservable : IObservable<Subject>

{

// List of observers and the instance of subject

private List<IObserver<Subject>> _subjectObservers;

private Subject _subject;

// Accept a subject instance which we shall observe

public SubjectObservable(Subject subject)

{

_subjectObservers = new List<IObserver<Subject>>();

_subject = subject;

}

// This method allows the observers to attach themselves. It returns a disposer object to the observer

// which the observer can utilize to unsubscribe

public IDisposable Subscribe(IObserver<Subject> observer)

{

if (!_subjectObservers.Contains(observer))

{

_subjectObservers.Add(observer);

}

return new Disposer(_subjectObservers, observer);

}

// This method is used to inspect the subject over time. Usually used with a timer or an event

public void inspectSubject()

{

foreach (IObserver<Subject> observer in _subjectObservers)

{

observer.OnNext(_subject);

}

// Private class Disposer: Implements the IDisposable. Observable returns an instance to the observer for easy unsubscription

private class Disposer : IDisposable

{

// The observers list recieved from the observable

private List<IObserver<Subject>> _subjectObservers;

// The observer instance to unsubscribe

private IObserver<Subject> _observer;

public Disposer(List<IObserver<Subject>> _subObservers, IObserver<Subject> observer)

{

_subjectObservers = _subObservers;

_observer = observer;

}

public void Dispose()

{

if (_subjectObservers.Contains(_observer))

{

_subjectObservers.Remove(_observer);

}

// Class Subject Observer - The object that attaches itself to a observable and recieves notifications

class SubjectObserver : IObserver<Subject>

{

// The disposer returned by the observable when subscribing

private IDisposable _disposer;

// Unique instance name to track the observer

private string _instaceName;

public SubjectObserver(IObservable<Subject> provider, string instanceName)

{

if (provider != null)

{

_disposer = provider.Subscribe(this);

_instaceName = instanceName;

}

// The observable invokes this method to pass the Subject object to the observer

public void OnNext(Subject value)

{

Console.WriteLine("[" + _instaceName + "] " + value.Counter);

}

// Usually called when a transmission is complete. Not implemented.

public void OnCompleted()

{

throw new NotImplementedException();

}

// Usually called when there was an error. Didn't implement.

public void OnError(Exception error)

{

throw new NotImplementedException();

}

// Invoke the disposer recieved from the observable. This will unsubscribe

public void Dispose()

{

_disposer.Dispose();

}

Okay, so every time we read the value of the counter data, the value increases. The subject is inspected by the observable and the observable passes the subject to the observers. Each observer again prints the counter and increases the value by one. This continues. 🙂

Recent Posts

Recent Comments

Archives

Categories