Przekazanie wartości pomiędzy dll-kami, lub pomiędzy dll-ką a głównym programem

Witam.
Podpowiedzcie jak wykonać to co napisałem w temacie. Szukam, szukam, googluję i nic nie mogę znaleźć. Pomóżcie. Błagam. :)

A jak Ty sobie wyobrażasz przekazywanie danych między bibliotekami DLL? Możesz coś więcej napisać o tym co chcesz zrobić? Sposobów może być wiele, ale nikt nie jest pewny co się przyda akurat do Twojego przypadku;

Podaj więcej przydatnych informacji to może wtedy zaczniemy dyskusję;

Dobra. Podaję przykład.
Są dwie biblioteki DllA i DllB. W każdej z nich są TForm: TFormA1, TFormA2, TFormB1, TFormB2. Główna aplikacja uruchamia te TFormy niezależnie. Jednakże istnieje możliwość z formy TFormB1 uruchomić formę TFormA1. Na formie TFormA1 wpisujemy dane, dodają się one do bazy danych i wtedy do TFormB1 przekazywane jest id właśnie dodanego rekordu. To id może być również zapisane w głównej aplikacji (TFormMain).

Czy taki opis wystarczy??

Czy taki opis wystarczy??

To zależy - potrzebne są jakieś funkcje do tego;

Jeżeli chcesz to zrobić tak, jak napisałeś tutaj:

Jednakże istnieje możliwość z formy TFormB1 uruchomić formę TFormA1. Na formie TFormA1 wpisujemy dane, dodają się one do bazy danych i wtedy do TFormB1 przekazywane jest id właśnie dodanego rekordu.

to wychodzin na to, że formy uruchamiają się wzajemnie bez wiedzy formularza głównego;

Kwestią jest jeszcze to, w jaki sposób wywoływane i oprogramowane są formularze w bibliotekach; Jeżeli stworzyłeś spbie te okna jako dialogi (polecam takie rozwiązanie), to wszystkim będzie zarządzać główny formularz, stąd każde wywołanie okna będzie obsługiwane tylko i wyłącznie przez niego; Unikniesz bałaganu i zagmatfania co będzie dla Ciebie lepsze;

Optuję za tym, by algorytm zapisujący informacje do bazy danych był dostępny tylko dla głównego formularza, a z bibliotek wywoływane byłyby okna dialogowe (coś jak InputBox czy MessageBox), które za zadanie będą miały pobierać informacje od użytkownika, po czym będą je przekazywać do głownego i tam będą oprogramowane dalsze czynności;

Jeżeli w bibliotekach będziesz miał zaimplementowane okna dialogowe to nie dość, że kod odpowiedzialny za dodawanie danych (jedna forma) i ich wyświetlanie (druga forma) będzie mógł być zapisany w jednej procedurze, to jeszcze będzie można dopuścić taką możliwość, że TFormA1 będzie mogło uruchomić TFormB1;

Ważne jest to, w jaki sposób będziesz Ty chciał oprogramować wywoływanie okien i pobieranie / wyświetlanie informacji, bo Tobie ma być wygodnie, a użytkownik i tak zobaczy ten sam efekt;

Jeżeli coś źle zrozumiałem to proszę mnie poprawić;

No to teraz mi dopiero zagmatwałeś.

To może z opisu ogólnego przejdę do szczegółowego. Tworzę prostą aplikację magazynową. Produkty, zakupy produktów, sprzedaż produktów. Doszedłem do wniosku, że lepiej i elastyczniej będzie, gdy wszelkie formularze z tych poszczególnych części będą w oddzielnych bibliotekach. W bibliotece products.dll są formularze do obsługi dodawania i edytowania danych o produkcie, pokazania listy wszystkich produktów i kasowania produktu/ów. W bibliotece purchases.dll są formularze do obsługi dodawania i edytowania danych o zakupach, lista wszystkich zakupów i kasowania zakupu. W bibliotece selling.dll podobnie jak wyżej. Główna forma programu zawiera tylko TMainMenu i są wywoływane odpowiednie formularze z dll-ek. Generalnie gdy wywoływane formularze są głównego okna jest ok. Ale założyłem taką sytuację. Użytkownik chce dodać nowy zakup. Wie, że danego produktu nie ma w bazie. Naciska przycisk "Dodaj produkt" i wtedy otwiera się okienko do dodania produktu, które jest zawarte w bibliotece products.dll. Po dodaniu produktu do bazy jego id jest przekazywane z powrotem do formy, która je wywołała, czyli dodawanie nowego zakupu, która to forma zawarta jest w purchases.dll w celu załadowania z bazy właśnie dodanych danych. I w tym miejscu mam problem. Może teraz bardziej jasno wyjaśniłem mój problem. :)

No teraz do mi wbiłeś klina... :P Żeby uniknąć zbędnego pisania będę Cię cytował;

W bibliotece products.dll są formularze do obsługi dodawania i edytowania danych o produkcie, pokazania listy wszystkich produktów i kasowania produktu/ów. W bibliotece purchases.dll są formularze do obsługi dodawania i edytowania danych o zakupach, lista wszystkich zakupów i kasowania zakupu. W bibliotece selling.dll podobnie jak wyżej.

No to ja nie widzę innego wyjścia, jak oprogramować każde okno w tych bilbiotekach jako okno dialogowe (bez względu na to, czy ma coś zwracać czy nie); Czyli dla każdego okna tworzysz osobno klasę (baza - TObject), która będzie obsługiwać i gromadzić potrzebne informacje z formularza; Dalej idąc tworzysz dla każdego formularza funkcję / procedurę, w ciele której zaprogramowane będzie tworzenie i uzupełnianie formularza odpowiednimi danymi (podawanymi w argumentach lub pobieranymi z bazy danych); Dzięki temu będziesz mógł za wywołaniem jednej funkcji \ procedury wyświetlać uzupełniony bądź nie formularz, a po jego zamknięciu chwytać informacje z niego płynące; Inaczej mówiąc - jedna funkcja \ procedura będzie załatwiała wiele linii kodu, co pozytywnie wpłynie na ilości kodu obsługującego daną operację; Mało tego - okna będzie można wywoływać zarówno w głownym formularzu jak i z formularzy z bibliotek (w ciele biblioteki wystarczy jedna linia kodu ładująca ową funkcję / procedurę z innej); System wywoływania okienek będzie prosty, intuicyjny i łatwy w użyciu, a co za tym idzie łatwiej będzie się z niego korzystało i szybciej będzie można modyfikować go;

Użytkownik chce dodać nowy zakup. Wie, że danego produktu nie ma w bazie. Naciska przycisk "Dodaj produkt" i wtedy otwiera się okienko do dodania produktu, które jest zawarte w bibliotece products.dll. Po dodaniu produktu do bazy jego id jest przekazywane z powrotem do formy, która je wywołała, czyli dodawanie nowego zakupu, która to forma zawarta jest w purchases.dll w celu załadowania z bazy właśnie dodanych danych.

No i właśnie o to chodzi - dzięki okienkom dialogowym w prosty sposób pobierzesz informacje od użytkownika, po czym przechwycisz je i wykorzystasz dalej, wywołując nowe okienko i odpowiednio je uzupełnisz;

To wcale nie jest takie trudne, tylko trzeba się nad tym zastanowić i nie komplikować sobie pracy; Popatrz:

Po dodaniu produktu do bazy jego id jest przekazywane z powrotem do formy, która je wywołała

Gdy zrobisz okienko dialogowe wraz z klasą do jej obsługi, wystarczy, że utworzysz funkcję, która będzie zwracała ID dodanego produktu, po czym będziesz mógł wywołać następne okno (tu: do dodawania nowego zakupu) poprzez fukcję, która jako argument m.in. pobierze ID produktu i wyświetli informacje o nim;

Czyż nie proste rozwiązanie? Inaczej niestety tego nie widzę - zbyt wiele kombinowania jak dla mnie...

Jedno pytanie. Być może banalne. Co masz na myśli pisząc "okienko dialogowe"?

Podpowiedz mi co powinienem zmienić. Obecnie robię to w ten sposób.

Tworzę bibliotekę. Pod biblioteką dodaję Form. Na nm układam wszelkiego rodzaju komponenty. Przypisuję zdarzenia do tych komponentów. Kod zdarzeń zapisany jest w unit-cie tworzącym formę. W ciele biblioteki piszę taką procedurę:

procedure ShowForm;
begin
Form := TForm.Create(Application);
Form.ShowModal;
Form.Free;
end;

Eksportowana jest ta procedura. W głównym programie ładuję tą funkcję z biblioteki i ją wywołuję.
Jak to zmodyfikować, aby było zgodne z Twoim opisem?

Co masz na myśli pisząc "okienko dialogowe"?

Miałem taką cichą nadzieję, że wiesz co to są okna dialogowe...:

Okno dialogowe - w informatyce okno służące do zapytania użytkownika o potrzebne programowi dane, a następnie zamykane (zwykle przyciskiem Ok). Zazwyczaj nie jest głównym oknem aplikacji. Wyjątkiem są tzw. aplikacje dialogowe, prezentujące ciąg okien dialogowych, takie jak programy instalacyjne lub kreatory.

Okno dialogowe może być modalne, czyli blokować przetwarzanie zdarzeń przez inne okna aplikacji. Większość okien dialogowych jest modalna, choć niektóre aplikacje tworzą też niemodalne okna dialogowe, np. paski narzędzi. Istnieją również systemowe okna modalne - okna dialogowe blokujące przetwarzanie zdarzeń przez wszystkie pozostałe okna, np. okno dialogowe pytające o zamknięcie systemu.

Źródło: Wikipedia

No to już teorię znamy, teraz czas na praktykę; Jeżeli tworzysz nową bibliotekę w delphi, zostaje utworzony moduł ze jej szkieletem; Dodaj do projektu biblioteki nowy formularz - utworzony zostanie nowy moduł, w którym oprogramuj wszystkie w nim zawarte kontrolki (według własnych potrzeb i upodobań); Jeżeli już będziesz miał taki moduł gotowy, musisz napisać klasę, która będzie odpowiedzialna za tworzenie okna, uzupełnianie (przed wyświetleniem (jeżeli zachodzi taka potrzeba)), wyświetlanie oraz przechwycenie informacji w zawartych w kontrolkach przy zamykaniu formularza; Mimo tego, że okno zostanie zamknięte, przechwycone informacje będzie można wykorzystać aż do usunięcia z pamięci obiektu; Klasa ta będzie opisem nie tylko formularza, ale i struktury przechowującej informacje z okna - czyli klasą dialogu; Jeżeli już napiszesz taką klasę (zawarta musi być w module formularza!) przejdziesz do głownego unitu biblioteki i tam napiszesz funkcję (jeżeli okno dialogowe ma pobierać informacje od urzytkownika i zwracać je) lub procedurę (jeżeli okno ma służyć tylko do przedstawiania informacji), która będzie tworzyć obiekt (klasy dialogowej), uzupełniać go danymi jeśli trzeba oraz wyświetlać okno; Jak użytkownik skończy pracę z oknem (zamknie ją krzyżykiem lub odpowiednim innym przyciskiem) sprawdzisz, czy zamknął okno poprawnie i jeśli okno ma zwracać jakieś informacje obiekt je przechwyci, po czym przekaże je do Result funkcji; To wszystko; Teraz wystarczy wyeksportować tylko tą jedną funkcję \ procedurę i gotowe;

W momencie, gdy będziesz chciał wywołać ww okno dialogowe wystarczy, że wywołasz jedną funckję \ procedurę, a cała reszta zostanie wykonana tak, jak zaprogramowałeś; Tylko jedna linijka, a pobierze potrzebne informacje i przekaże je dalej, do wykorzystania gdzie tylko będziesz potrzebował;

Jak źle oprogramujesz formularz lub chcesz go zmodyfikować \ unowocześnić - otwierasz projekt biblioteki i zmieniasz co chcesz; Zmiany wprowadzasz w jednym miejscu, a wszędzie, gdzie wywołujesz okno będą widoczne;

Jak dla mnie świetna sprawa, dla Ciebie - nie wiem; To jak napisać klasę do obsługi okna dialogowego nie będę Ci tłumaczył, musisz znać chociaż podstawy OOP i wiedzieć co się chce osiągnąć; Masz za to z załączniku artykuł znaleziony gdzieś nie wiem gdzie i kiedy w sieci (może nawet na 4p), w którym przedstawione są podstawy tworzenia własnych okien dialogowych, ich tworzenie, wyświetlanie i przechwytywanie potrzebnych informacji; Jest bardzo ubogi, ale da się na nim oprzeć;

Czytaj, testuj, kombinuj (i pij kawę :P) a dojdziesz do tego; Nie jest to takie trudne jak się wydaje;