Zajęcia, rok akademicki 2014/2015, 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. 2015.02.24, Wprowadzenie do projektowania obiektowego
   • Omówienie programu wykładu
   • 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 1
   Zestaw 1 (do 2015-03-10)
2. 2015.03.03, Język UML
   • Diagramy klas
     • Diagramy modeli pojęciowych
     • Diagramy obiektów (klas)
     • Diagramy implementacyjne (struktur relacyjnych)
     • Diagramy obiektów
   • Diagramy sekwencji
   • Diagramy czynności
   • Diagramy stanów
   Notatki do wykładu 2
   Zestaw 2 (do 2015-03-17)
3. 2015.03.10, SOLID GRASP
   • SOLID
   • GRASP
   Notatki do wykładu 3
   Zestaw 3 (do 2015-03-24)
4. 2015.03.17
   • Wzorce podstawowe
     • Interface vs abstract class
     • Delegation vs inheritance
   • Wzorce kreacyjne
     • Singleton
     • Monostate
     • Factory
     • Template method
     • Abstract factory
     • Object pool
   Notatki do wykładu 4
   Zestaw 4 (do 2015-03-31)
5. 2015.03.24
   • Wzorce strukturalne
     • Builder
     • Facade
     • Decorator
     • Proxy
     • Adapter
     • Flyweight
     • Bridge
     • Read-only interface
   Notatki do wykładu 5
   Zestaw 5 (do 2015-04-14)
6. 2015.03.31
   • Wzorce czynnościowe (1)
     • Composite
     • Interpreter
     • Visitor
     • Null object
     • Iterator
   Notatki do wykładu 6
   Zestaw 6 (do 2015-04-21)
7. 2015.04.14
   • Wzorce czynnościowe (2)
     • Observer
     • Mediator
     • Event Aggregator
     • Memento
   Notatki do wykładu 7
   Zestaw 7 (do 2015-05-05)
8. 2015.04.21
   • Wzorce czynnościowe (3)
     • Chain of Responsibility
     • Command
     • State
     • Strategy
     • Template method
   Notatki do wykładu 8
   Zestaw 8 (do 2015-05-19) termin wydłużony o tydzień w stosunku do pierwotnego z powodu godzin rektorskich 12-05
9. 2015.04.28, Wzorce architektury aplikacji (1)
   • Automated code generation
   • Object-relational mapping
     • Database first vs model first vs code first
     • Metadata mapping
     • Navigation properties
     • Lazy loading
     • One-to-one
     • Many-to-many
     • Hierarchy mapping (TPC/TPH/TPT)
     • 1st level cache vs 2nd level cache
     • Query language
     • Global filter
     • Soft delete
   Notatki do wykładu 9
   (bez zestawu)
10. 2015.05.05, Wzorce architektury aplikacji (2)
    • Dependency Injection/Inversion of Control
    Notatki do wykładu 10
    Zestaw 9 (do 2015-05-26)
11. 2015.05.12, Wzorce architektury aplikacji (3)
    • Repository - Concrete Repository vs Generic Repository
    • Unit of Work
    Notatki do wykładu 11
    Zestaw A (do 2015-06-02)
    Przykład z wykładu
12. 2015.05.19, Wzorce architektury aplikacji (4)
    • Model-View-Controller
    • Model-View-Presenter
    Notatki do wykładu 12
    Zestaw B (do 2015-06-09)
    Ranking punktowy na 2015-05-19
13. 2015.05.26
    • Behavior-Driven Design, testowanie za pomocą ram typów zastępczych
    • Design by Contract: Code Contracts
    • Automatyczne generowanie przypadków testowych: Pex, Pex for fun
    Notatki do wykładu 13
    Zestaw C (ostatni) (do 2015-06-09)
14. 2015.06.02
    • Interoperability
    • PKI, X.509, PKCS#12
    • XmlDSign, XaDES
    Notatki do wykładu 14
15. 2015.06.09
    • 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