W jaki sposób można stworzyć plik zasobów lokalnych strony aspx?

1. Należy otworzyć stronę w Design Mode.
2. Z menu Tools wybrać Generate Local Resource

Tak wygląda edytor zasobów lokalnych strony:



W kodzie dodany zostaje meta:resourcekey:

<asp:Label ID="Label2" runat="server" Text="Label" meta:resourcekey="Label2Resource1"></asp:Label>

Pod tym adresem: www.platerow.org/mojzesz powstaje strona poświęcona projektowi "Mojżesz z Mężenina" związanemu z tekstem Janusza Korczaka i z fotografią otworkową.

Zasoby globalne aplikacji webowej (Global resources) powinny być używane gdy potrzeba mieć dostęp do wspólnego źródła zasobów (tekstów i obrazków) na wielu stronach tej aplikacji. Zasoby globalne są umieszczane w specjalnym katalogu App_GlobalResources znajdującym się w katalogu głównym aplikacji. Można tworzyć oddzielne zasoby dla różnych języków (kultur).
Dodawanie zasobu globalnego strony: w Solution Explorer należy kliknąć Add -> New Item i wybrać Resource File:


Plik ma rozszerzenia .resx, można go sobie nazwać jak się komu podoba (ja nazwałem go Teksty.resx).

W edytorze można dodawać kolejce zasoby:


Aby dodać zasoby dla innego języka należy dodać do wspomnianego katalogu App_GlobalResources kolejny plik o odpowiedniej nazwie, np: Teksty.pl.resx (dla języka polskiego). Aplikacja automatycznie wykryje ustawienia językowe przeglądarki i użyje odpowiednich zasobów.

Powiązanie zasobu globalnego z kontrolką:
a) W edytorze graficznym: Wyświetlamy właściwości kontrolki i klikamy na (Expressions):

Aby powiązać właściwość Text kontrolki Label o nazwie Label1 z zasobem WelcomeText należy wpisać:



b) W kodzie aspx:
W kodzie aspx wygląda to tak:

<asp:Label ID="Label1" runat="server" Text="<%$ Resources:Teksty, WelcomeText %>">

c) W kodzie C# (code-behind file):

protected void Page_Load(object sender, EventArgs e)
{
    Label1.Text = Resources.Teksty.WelcomeText;
}

Metoda szablonowa (Template Method) Metoda szablonowa jest zdefiniowana w klasie bazowej. Jej zadaniem jest wywoływanie innych metod klasy bazowej, które mogą być przedefiniowane w klasach dziedziczących. Sama metoda szablonowa pozostaje niezmienna i zawiera algorytm złożony z elementów wykonywanych przez metody prymitywne. Klasy dziedziczące mogą zmienić metody prymitywne, ale podstawowy algorytm nie ulega zmianie.

using System;
using System.Collections.Generic;
using System.Text;

namespace TemplateMethodExample
{
    public abstract class ApplicationFramework
    {
        protected abstract void Init();
        protected abstract void DoSthUseful();
        protected abstract void Cleanup();

        public void TemplateMethod()
        {
            // Szablon działania aplikacji
            Init();
            DoSthUseful();
            Cleanup();
        }
    }

    public class MyApp : ApplicationFramework
    {
        protected override void Init()
        {
            Console.WriteLine("Init");
        }

        protected override void DoSthUseful()
        {
            Console.WriteLine("DoSthUseful");
        }

        protected override void Cleanup()
        {
            Console.WriteLine("Cleanup");
        }
    }

    // Tu kolejne klasy dziedziczące po ApplicationFramework...

    class Program
    {
        static void Main(string[] args)
        {
            ApplicationFramework app = new MyApp();
            app.TemplateMethod();
        }
    }
}

Adapter (należący do grupy wzorców strukturalnych) pozwala klasom współpracować ze sobą, co w innym przypadku byłoby niemożliwe z powodu niezgodności interfejsów między tymi klasami. Adapter tłumaczy wywołania metod jego interfejsu na wywołania oryginalnego (docelowego) interfejsu.

Trochę mało życiowy przykład:

namespace AdapterExample
{
    public interface IOpenable
    {
        void Open();
    }

    // Słoik nie implementuje interfejsu IOpenable
    // Adaptee
    public class Jar
    {
        public void TwistOff()
        {
            Console.WriteLine("Jar::TwistOff()");
        }
    }

    // Adapter do słoika
    public class JarAdapter : IOpenable
    {
        private Jar _Jar;
        public JarAdapter()
        {
            _Jar = new Jar();
        }

        public void Open()
        {
            _Jar.TwistOff();
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            IOpenable JarOpen = new JarAdapter();
            JarOpen.Open();
        }
    }
}

Modyfikuje czynności obiektu. Reprezentuje stan obiektu docelowego, gdy obiekt ten zachowuje się inaczej w zależności od jakiejś zmiennej. Zastępuje użycie if i switch. Używa się go, gdy stan obiektu docelowego zmienia się: np. samochód może się zepsuć, żaba zamienia się w księżniczkę, człowiek ma różne nastroje, kot może być żywy albo martwy, etc..

(Stan – stan abstrakcyjny; Stan1, stan2 – stany konkretne)

Przykład. Człowiek jest domyślnie ignorantem, ale jak zostanie wyedukowany to zmieni swój stan i będzie miał do powiedzenia coś ciekawego.

public class Man
{
    public interface State
    {
        string SaySomething();
    }

    public class Ignorant : State
    {
        public string SaySomething()
        {
            return "I've got nothing to say";
        }
    }

    public class Educated : State
    {
        public string SaySomething()
        {
            return "Every word is like unnecessary stain on silence and nothingness";
        }
    }

    private State state;
    public Man()
    {
        state = new Ignorant();
    }

    public void SaySomething()
    {
        Console.WriteLine(state.SaySomething());
    }

    public void Educate()
    {
        state = new Educated();
    }
}

class Program
{
    static void Main(string[] args)
    {
        Man man = new Man();
        man.SaySomething();
        man.Educate();
        man.SaySomething();
    }
}

Pośrednik (Proxy) to wzorzec strukturalny, który umożliwia dostęp do innego obiektu. Pośrednik i implementacja mają wspólny interfejs.



Obiekt Proxy może na przykład wywoływać metody na obiekcie łączącym się z bazą danych (stanowiącym warstwę dostępu do danych). Może pośredniczyć w dostępie do obiektu, którego tworzenie jest kosztowne (połączenie sieciowe, obiekt zajmujący bardzo dużo pamięci) lub też może chronić dostęp do obiektu docelowego (np. poprzez sprawdzenie hasła).
Podział:

• Pośrednik zdalny (remote proxy) – pośredniczą w dostępie do obiektów zdalnych,
• Pośrednik wirtualny (virtual proxy)– opóźniona inicjalizacja,
• Pośrednik zabezpieczający (protection proxy)– chroni dostęp do implementacji,
• Inteligentne odwołanie (smart reference)– wzbogaca czynności realizowane przez obiekt implementacji.

namespace ProxyExample
{
    public interface IOpenable
    {
        void Open();
    }

    public class DoorProxy : IOpenable
    {
        public DoorProxy()
        {
            Console.WriteLine("DoorProxy::Constructor");
        }

        private DoorMain _Door = null;
        public void Open()
        {
            // to jest 'lazy initialization'
            if (_Door == null)
                _Door = new DoorMain();
            // tu można by na przykład poprosić o podanie hasła przed otworzeniem drzwi
            _Door.Open();
        }
    }

    public class DoorMain : IOpenable
    {
        public DoorMain()
        {
            Console.WriteLine("DoorMain::Constructor");
        }

        public void Open()
        {
            Console.WriteLine("DoorMain::Open()");
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            DoorProxy dp = new DoorProxy();
            dp.Open();
        }
    }
}