This tutorial shows how to create a Windows form and how to make this interact with an existing COBOL program. The form is generated in managed COBOL. The form calls an intermediary program to map .NET data types onto COBOL data types. The intermediary program then calls the existing COBOL program to perform the business logic.
The solution has three programs:
As a prerequisite step for this tutorial, you need to build the BookWrapper and LegacyBook projects that are part of the WinBook sample as follows:
This loads the WinBook solution in Solution Explorer. Notice that this solution consists of three projects - BookWrapper, LegacyBook and WinFormBook. WinFormBook is emboldened which indicates it is the startup project of the solution - that is the project that runs when you start the debugger.
The build creates two binaries, BookWrapper.dll and LegacyBook.dll, in the WinFormBook\bin\Debug subfolder of the WinBook solution. You can close the solution.
In this section, you create a Windows form and then you paint the form. You can also examine the code generated.
Visual Studio creates the project and automatically opens the form in the designer.
|Control||Name Property||Text Property|
|TextBox||textBoxStockNo (the case is significant)||(blank)|
|TextBox||textBoxTitle (the case is significant)||(blank)|
|Label||label4 (the case is significant)||(blank)|
|TextBox||textBoxPrice (the case is significant)||(blank)|
|Button||button1 (the case is significant)||Read|
To display the properties, click the label and then view the Properties pane. You can then scroll to the relevant property and edit it.
For more information on the generated code, see the tutorial Tutorial: Developing .NET COBOL Applications.
Now you need to add the code for the button click, which needs to call the legacy COBOL program and to populate the form with the information returned.
method-id button1_Click final private. local-storage section. 01 input-string string. 01 my-exception type System.Exception. procedure division using by value sender as object e as type System.EventArgs. set input-string to textBoxStockNo::Text try set my-book to type BookWrapper.Book::Read(input-string) invoke self::PopulateForm(my-book) catch my-exception invoke self::DisplayException(my-exception) end-try end method.
method-id PopulateForm final private. procedure division using my-book as type BookWrapper.Book. if my-book <> null set textBoxStockNo::Text to my-book::StockNumber set textBoxTitle::Text to my-book::Title set textBoxPrice::Text to type System.Convert::ToString(my-book::RetailPrice) else set textBoxStockNo::Text to "****" set textBoxTitle::Text to "*************************************" set textBoxPrice::Text to "****" end-if end method.
method-id DisplayException private. procedure division using by value ex as type System.Exception. set label4::Text to ex::Message set my-book to null invoke self::PopulateForm(my-book) end method.
The remaining errors are all associated with my-book. You can clear them when you have added the legacy code.
You now need to add the existing COBOL code that contains the business logic, so that the form can use it. This code is supplied in a LegacyBook project containing book.cbl.
In addition, you need some wrapper code to convert the data from .NET types to COBOL types. The Windows form uses .NET data types; these are System.String objects in our case. The book program uses COBOL types such as PIC X and PIC 99V99. The supplied program BookWrapper.cbl does this conversion, and you need to add this to the solution.
The supplied files are in the %PUBLIC%\Documents\Micro Focus\Visual COBOL\Samples folder in the Forms subfolder.
To add book.cbl and BookWrapper.cbl:
The projects are now added to the References folder in your solution.
You now need to add some code to the form to call the wrapper code and to clear the last of the red squiggles to do with my-book.
01 my-book type BookWrapper.Book.
You should now have no parsing errors, now that BookWrapper is declared. If you do have errors, check the supplied demonstration in Forms\ WinBook to see where yours differs.
This opens the Add New Item dialog box.
This adds an App.config file to the WinFormBook project.
This opens the Application Settings dialog box.
See Start > All Programs > Micro Focus Visual COBOL > Samples for the exact location of the samples on your machine.
You can now run the application:
To do this right-click the WinFormBook project in the Solution Explorer and then click Set as StartUp Project.
You can read data for stock numbers 1111 and 2222.
The sample code is available in the Samples folder, with all the Visual Studio and .NET examples, and in the Forms subfolder.
The client Windows form Form1.cbl is generated as COBOL. The user enters data into the form and receives the return data there. The client form does the following:
The BookWrapper.cbl program acts as an intermediary between the pre-existing COBOL program book.cbl and the Windows form. This enables you to leave the pre-existing COBOL unchanged.
The important point here is that you need to use compatible types when mixing languages. The Windows form stores the data as .NET types and yet the Book program expects data as COBOL types.
The purpose of the BookWrapper program is to map your COBOL PICTUREs to .NET System.Strings. The program receives data from the Windows form as System.Strings, and maps them onto standard COBOL data types before passing them to the pre-existing book program.
The working storage declares the data items in a book record by using a copybook, as follows:
working-storage section. copy "book-rec-dotnet.cpy" replacing == (prefix) == by == book ==. ...
The copybook book-rec-dotnet.cpy declares the book-details record. It declares book-title and book-stockno as COBOL pictures and also as properties so that Getter/Setter methods can be used to access them. The copybook contains:
01 (prefix)-details. 03 (prefix)-text-details. 05 (prefix)-title pic x(50) property as "Title". ... 03 (prefix)-stockno pic x(4) property as "StockNumber".
The following get property method gets a pointer to the book-details record:
property-id BookDetails pointer. getter. set property-value to address of book-details end property.
The Read method is implemented as follows:
method-id Read static. local-storage section. 01 file-status pic xx. procedure division using by value stockno-in as string returning myBook as type BookWrapper.Book. set myBook to new BookWrapper.Book() set myBook::StockNumber to stockno-in call "BookLegacy" using by value readRecord by value myBook::BookDetails by reference file-status invoke self:RaiseExceptionIfError(file-status) end method.
shows a .NET System.String, stockno-in, being passed in from client form. It also shows an instance of the Book class being returned. BookWrapper.cbl defines a new .NET type, Book, which can be used by programs written in any .NET language.
set myBook to new BookWrapper.Book()
creates a new instance of the BookWrapper class.
takes the data from the .NET System.String (stockno-in) and stores it as the StockNumber property of myBook. This property is declared in the copybook as a picture string, and so the data is stored as a standard COBOL data type in book-stockno. The COBOL Compiler implicitly converts the data from the .NET string into a COBOL usage display item (pic x).
call BookLegacy using ...
calls the legacy program, book.cbl. It passes it the “BookDetails” property of myBook. If you look at the code in BookWrapper.cbl, you can see that what BookDetails does is pass a pointer to the BookRecord structure defined in book-rec-net.cpy. This structure matches the structure in the old book-rec.cpy, so what the legacy Book program sees is a book record being passed in by reference – which is what it expects. Book reads the stock number from this record, reads a record from the indexed file, and then puts the data in the other fields of the record.
checks the file status returned from reading the file, and raises a .NET exception if there was an error. Exceptions are the standard .NET mechanism for signaling error conditions.
The book.cbl program is a long-standing demonstration program that has been shipped with Micro Focus products for several years. It is written in procedural COBOL. The program reads and writes to an indexed file containing book records.
In this solution, the Book program is recompiled to managed code without any changes. Recompiling the program exposes it as a class and exposes its main entry point as a static method.
The program's Linkage section defines data as standard COBOL types, such as PIC X, which non-COBOL client programs do not handle. These types need to be mapped to .NET compatible types before communication with the client program. This mapping is done by the intermediary program BookWrapper.cbl.