COBOL-to-C# Converter: Side-by-Side Code Comparison

SoftwareMining's automated, rule-based COBOL-to-C# Translation Toolkit converts enterprise COBOL applications into maintainable C# source code. This page compares a small COBOL program with the corresponding C# code generated by the translator.

The comparison shows how COBOL business logic, data definitions and program flow are represented in readable, object-oriented C# code. For a complete application, the translated system should be validated against the original COBOL application through functional-equivalence testing .

Download COBOL-to-Java and C# Conversion Toolkit | Free Evaluation

This introductory comparison focuses on the readability and structure of the generated code. Complete enterprise conversions must also address advanced COBOL requirements such as GO TO control flow, dead-code analysis, REDEFINES, CICS integration and pointer handling.

For detailed coverage of supported COBOL language constructs, platform technologies, data handling and translation patterns, see the Enterprise COBOL-to-C# Translator Feature List .

Enterprise Case Study: Verisk COBOL-to-C# Modernization

Key COBOL-to-C# Conversion Features

COBOL 01-level data declarations are converted into generated Data Access Object (DAO) classes that preserve COBOL structures such as REDEFINES, computational fields and OCCURS DEPENDING ON (see the WS-DATA structure below).
COBOL 01-level record definitions in the FILE SECTION are converted into Object-Relational Mapping (ORM) classes for use by the translated C# application.
COBOL 01-level WORKING-STORAGE definitions used as record areas by CICS READ and WRITE commands are also converted into ORM classes.
Unreferenced 01-level declarations are automatically commented out in the generated code, reducing unnecessary clutter while retaining the original definitions for reference.
The translator avoids generating unused DAO references and reuses shared data structures where possible, reducing duplication in the generated code.
GO TO control flow is converted into structured IF, switch and loop constructs where practical. More complex irreducible paths are preserved through controlled patterns supported by the SoftwareMining Framework libraries.
Translated batch programs can be executed from the command line or integrated with enterprise job schedulers. Supported JCL can also be converted into Unix shell scripts or Windows batch files .
Translated online applications can be deployed on Microsoft IIS or ASP.NET Core and integrated with standard enterprise database, messaging and security services.

See: Runtime Performance Comparisons

COBOL to C#: Side-by-Side Code Comparison

  PROGRAM-ID. LOAN.
  DATA DIVISION.
  FILE SECTION.

  WORKING-STORAGE SECTION.
  01  WS-VARS.
    05 PRINCIPAL          PIC 9(9) VALUE 0.
    05 INTEREST-RATE      PIC 99V99 VALUE 0.
    05 LOAN-LENGTH        PIC 99 VALUE 0.
    05 NEXT-INTEREST      PIC 99V99.
    05 NEXT-YEAR          PIC 99.
  01 CLIENT-RECORD.
    05 NAME               PIC X(20).
    05 ADDRESS            PIC X(20) OCCURS 3 TIMES.
    05 ID                 PIC 9(4) COMP.

  ...

/// Sample COBOL to C# translated code
namespace Softwaremining.Cobol2CSharp.Example
{
 public sealed class Loan : BaseService {
  
// Note: 01 level WS-VARS name is simplified (Optional)
// and converted to a DAO
// The DAO handles REDEFINES, COMP, OCCURS-DEPENDING, ...
  
  private Vars ;
  
// Client-RECORD has been translated to ClientRecord DAO,
// but since the program does not reference ClientRecord,
// it will automatically be commented out.
  
  
  // private ClientRecord clientRecord;
  
  ...
  /// constructor
  public Loan(BaseService parent) : base(parent)
  {
    vars = new Vars(this);
    // clientRecord = new ClientRecord(this);

   ...

  * Main entry point to program
   LOAN-MAIN-001.

  *  -
  * CLEAR SCREEN AND READ DATA
  *  -

       IF LOAN-LENGTH > 4 THEN
          COMPUTE START-YEAR = LOAN-LENGTH - 4
       ELSE
          COMPUTE START-YEAR = 0.

       IF INTEREST-RATE > 0.4 THEN
          COMPUTE START-INTEREST = INTEREST-RATE - 0.4
       ELSE
          COMPUTE START-INTEREST = 0
       END-IF

       MOVE 1 TO YEAR-ROW.

  *  -
  * GO THRU THE NUMBER OF YEARS
  *  -

       MOVE "% Rate->" TO DSP-NO-YRS(1).
       MOVE START-YEAR TO NEXT-YEAR
       PERFORM VARYING YEAR-ROW FROM 2 BY 1 UNTIL YEAR-ROW = 11
         PERFORM DO-NEXT-ROW
         ADD 1 TO NEXT-YEAR
       END-PERFORM.

  *  -
  *  AND EXIT
  *  -
       STOP RUN.

/// <summary>
/// Main entrance to program
/// </summary>
protected void LoanMain ()
{
  
  //  -
  // CLEAR SCREEN AND READ DATA
  //  -
  
  if (vars.LoanLength > 4)
  {
    vars.StartYear = vars.LoanLength - 4;
  }
  else
  {
    vars.StartYear = 0;
  }

  if (vars.InterestRate > 0.4)
  {
    vars.StartInterest = vars.InterestRate - 0.4;
  }
  else
  {
    vars.StartInterest = 0;
  }

  vars.YearRow = 1;
  vars.setYearRow(1);

  
  //  -
  // GO THRU THE NUMBER OF YEARS
  //  -
  
  displayResult.SetNoYrs(0, "% Rate->");
  vars.NextYear = vars.StartYear;
  vars.YearRow = 2;

  while (vars.YearRow != 11)
  {
    DoNextRow();
    vars.NextYear = vars.NextYear + 1;
    vars.YearRow = vars.YearRow + 1;
  }

  
  //  -
  // AND EXIT
  //  -
  
  Stop();
}

  *
  * Calculates values for individual rows
  *
   DO-NEXT-ROW.

       MOVE START-INTEREST TO NEXT-INTEREST

       PERFORM VARYING INTEREST-COL FROM 1 BY 1
         UNTIL INTEREST-COL = 10
         MOVE NEXT-INTEREST TO DSP-RESULT(1, INTEREST-COL)
         PERFORM CALCULATE
         MOVE NEXT-RESULT TO DSP-RESULT(YEAR-ROW, INTEREST-COL)
         ADD 0.1 TO NEXT-INTEREST
       END-PERFORM.

/// <summary>
/// Calculates values for individual rows
/// </summary>
protected void DoNextRow ()
{
  vars.NextInterest = vars.StartInterest;

  vars.InterestCol = 1;

  while (vars.InterestCol != 10)
  {
    displayResult.SetResult(
      0,
      vars.InterestCol - 1,
      vars.NextInterest
    );
    Calculate();
    displayResult.SetResult(
      vars.YearRow - 1,
      vars.InterestCol - 1,
      vars.NextResult
    );
    vars.NextInterest = vars.NextInterest + 0.1;
    vars.InterestCol = vars.InterestCol + 1;
  }
}

  *
  * The next paragraph calculates CELL values
  *
   CALCULATE.
       COMPUTE INTDEC = NEXT-INTEREST / (12.0 * 100.0)
       COMPUTE NUMMONTHS = NEXT-YEAR * 12.0
       ...

/// <summary>
/// The next paragraph calculates CELL values
/// </summary>
protected void Calculate ()
{
  vars.Intdec = vars.NextInterest / (12.0 * 100.0);
  vars.Nummonths = (int)((double)vars.NextYear * 12.0);
  ...
}