Zajęcia, rok akademicki 2013/2014, semestr 2

Projektowanie obiektowe oprogramowania

Wykład skierowany jest do przyszłych architektów i projektantów systemów informatycznych oraz do wszystkich programistów zainteresowanych udoskonaleniem swojego warsztatu. Celem wykładu jest zapoznanie studentów z kanonem współczesnych narzędzi w zakresie projektowania obiektowego oprogramowania.

Materiał wykładu obejmuje:

• język UML w zakresie wymaganym przez projekty analityczne i techniczne
• przegląd katalogu refaktoryzacji
• przegląd katalogu wzorców projektowych (GoF) (m.in. Observer, Builder, Bridge, State, Strategy, Facade, Adapter, Mediator, itd.)
• przegląd katalogu wzorców aplikacyjnych (m.in. Event Aggregator, Model-View-Controller, Model-View-Presenter, Object-Relational Mapping, Dependency Injection, Mock Object)
• przegląd katalogu wzorców architektonicznych (m.in. Single Sign-on, SOA, Enterprise Service Bus, Command-Query Responsibility Separation)

Celem pracowni jest praktyczny kontakt z materiałem z wykładu.

Wymagania

Organizacja pracy

Egzamin

Wykłady

1. 2014.02.25
   • Wykład organizacyjny
   • Omówienie programu wykładu
   • Omówienie literatury
   • Wprowadzenie do języka UML
     • Diagramy klas
     • Diagramy obiektów
     • Diagramy czynności
   Notatki do wykładu 1
   Zestaw 1 (do 2014-03-11)
2. 2014.03.04
   • Wprowadzenie do języka UML, cd..
     • Diagramy sekwencji
   • Analiza obiektowa - Unified Process
     • Zbieranie wymagań: FURPS+, S.M.A.R.T.
     • Przypadki użycia - notacja skrócona, pełna
     • Model pojęciowy, techniki tworzenia ("lista kategorii", "metoda fraz rzeczownikowych")
   Notatki do wykładu 2
   Zestaw 2 (do 2014-03-19)
3. 2013.03.12
   • SOLID
   • GRASP
   Notatki do wykładu 3
   Zestaw 3 (do 2014-03-25)
4. 2013.03.19
   • Wzorce podstawowe
     • Interface vs abstract class
     • Delegation vs inheritance
   • Wzorce kreacyjne
     • Singleton
     • Monostate
     • Factory
     • Template method
     • Abstract factory
     • Object pool
     • Builder
   Notatki do wykładu 4
   Zestaw 4 (do 2013-04-08)
5. 2014.03.25
   • Wzorce strukturalne
     • Facade
     • Decorator
     • Proxy
     • Adapter
     • Flyweight
     • Bridge
     • Read-only interface
   Notatki do wykładu 5
   Zestaw 5 (do 2014-04-15)
6. 2013.04.09
   • Wzorce czynnościowe (1)
     • Composite
     • Interpreter
     • Visitor
     • Null object
     • Iterator
     • Observer
   Notatki do wykładu 6
   Zestaw 6 (do 2014-04-29)
7. 2014.04.08
   • Wzorce czynnościowe (2)
     • Mediator
     • Event Aggregator
     • Memento
   Notatki do wykładu 7
   Zestaw 7 (do 2014-05-06)
8. 2014.04.15
   • Wzorce czynnościowe (3)
     • Chain of Responsibility
     • Command
     • State
     • Strategy
     • Template method
   Notatki do wykładu 8
   Zestaw 8 (do 2014-05-13)
9. 2014.04.29, Wzorce architektury aplikacji (1)
   • Automated code generation
   • Object-relational mapping
   Notatki do wykładu 9
   (bez zestawu)
10. 2014.05.06, Wzorce architektury aplikacji (2)
    • Dependency Injection/Inversion of Control
    Notatki do wykładu 10
    Zestaw 9 (do 2014-05-27)
    Ranking punktowy na 2014-05-06
11. 2014.05.13, Wzorce architektury aplikacji (3)
    • Repository - Concrete Repository vs Generic Repository
    • Unit of Work
    Notatki do wykładu 11
    Zestaw A (do 2014-06-03)
12. 2014.05.20, Wzorce architektury aplikacji (4)
    • Model-View-Controller
    • Model-View-Presenter
    Notatki do wykładu 12
    Zestaw B (do 2014-06-11)
13. 2014.05.27
    • Behavior-Driven Design, testowanie za pomocą ram typów zastępczych
    • Design by Contract: Code Contracts
    • Testy interfejsu użytkownika: UI Automation, Teststack White
    • Automatyczne generowanie przypadków testowych: Pex, Pex for fun
    Notatki do wykładu 13
    Zestaw C (ostatni) (do końca semestru)
14. 2014.06.03
    • Interoperability
    • PKI, X.509, PKCS#12
    • XmlDSign, XaDES
    Notatki do wykładu 14
15. 2014.06.10
    • Service Oriented Architecture - przegląd pojęć
    • Przykłady: MSMQ, RabbitMQ, MassTransit
    Notatki do wykładu 15

Implementacje

namespace Uwr.OOP.BehavioralPatterns.EventAggregator
{
    public interface ISubscriber<T>
    {
        void Handle( T Notification );
    }

    public interface IEventAggregator
    {
        void AddSubscriber<T>( ISubscriber<T> Subscriber );
        void RemoveSubscriber<T>( ISubscriber<T> Subscriber );
        void Publish<T>( T Event );
    }

    public class EventAggregator : IEventAggregator
    {
        Dictionary<Type, List<object>> _subscribers = new Dictionary<Type, List<object>>();

        #region IEventAggregator Members

        public void AddSubscriber<T>( ISubscriber<T> Subscriber )
        {
            if ( !_subscribers.ContainsKey( typeof( T ) ) ) 
                _subscribers.Add( typeof(T), new List<object>() );

            _subscribers[typeof( T )].Add( Subscriber );
        }

        public void RemoveSubscriber<T>( ISubscriber<T> Subscriber )
        {
            if ( _subscribers.ContainsKey( typeof( T ) ) )
                _subscribers[typeof( T )].Remove( Subscriber );
        }

        public void Publish<T>( T Event )
        {
            if ( _subscribers.ContainsKey( typeof( T ) ) )
                foreach ( ISubscriber<T> subscriber in _subscribers[typeof( T )].OfType<ISubscriber<T>>() )
                    subscriber.Handle( Event );
        }

        #endregion
    }
}

namespace Uwr.OOP.BehavioralPatterns.Memento
{
    public class Caretaker
    {
        Stack undoStack = new Stack();
        Stack redoStack = new Stack();

        private Originator originator;

        public Caretaker( Originator o )
        {
            this.originator = o;
            this.originator.StateChanged += OriginatorStateChanged;
        }

        public void Undo()
        {
            if ( this.undoStack.Count > 1 )
            {
                // bieżący stan na redo
                Memento m = undoStack.Pop();
                redoStack.Push( m );

                Memento ps = undoStack.Peek();
                this.originator.RestoreMemento( ps );
            }
        }

        public void Redo()
        {
            if ( this.redoStack.Count > 0 )
            {
                Memento m = redoStack.Pop();
                undoStack.Push( m );
                this.originator.RestoreMemento( m );
            }
        }

        public void OriginatorStateChanged()
        {
            redoStack.Clear();

            Memento m = this.originator.CreateMemento();
            undoStack.Push( m );
        }
    }

    public class Originator
    {
        public event Action StateChanged;

        private string _state;
        public string State
        {
            get
            {
                return _state;
            }
            set
            {
                _state = value;

                if ( this.StateChanged != null )
                    this.StateChanged();
            }
        }

        public Memento CreateMemento()
        {
            Memento m = new Memento();
            m.State = this.State;
            return m;
        }

        public void RestoreMemento( Memento m )
        {
            this._state = m.State;
        }
    }

    public class Memento
    {
        public string State { get; set; }
    }
}

Literatura podstawowa

1. Wrycza, Marcinkowski, Wyrzykowski - Język UML 2.0 w modelowaniu systemów informatycznych
2. Fowler - Refactoring: Improving the Design of Existing Code
3. Gamma, Helm, Johnson, Vlissides: Design Patterns: Elements of Reusable Object-Oriented Software
4. B.Martin, M.Martin. Programowanie zwinne: zasady, wzorce i praktyki zwinnego wytwarzania oprogramowania w C#.
5. Larman - UML i wzorce projektowe. Analiza i projektowanie obiektowe oraz iteracyjny model wytwarzania aplikacji
6. Fowler - Patterns of Enterprise Application Architecture
7. Microsoft Patterns & Practices - Application Architecture Guide