Click here to Skip to main content
13,139,254 members (83,460 online)
Click here to Skip to main content
Add your own
alternative version


54 bookmarked
Posted 4 Dec 2006

Code generator, plug-in based

Rate this:
Please Sign up or sign in to vote.
Another code generator, plug-in based.

Sample Image


This article will show you how to create a simple code generator, plug-in based. A code generator can hugely improve your productivity as it does the repetitive work for you. Nowadays, computer systems are becoming bigger and complex. I worked on an ERP project in which there was about 470 tables. Suppose you have to map all the 470 tables to C# classes by hand. It is just a waste of time. Let the code generator work for you.


The core of the code generator is the API (Application Programming Interface) in which is defined its skeleton. In order to write plug-ins for the code generator, you must implement or inherit the interfaces or basic classes, respectively. See the diagram below for better elucidation.

Classes and interfaces responsibilities

The IConnector interface defines the contract for a connector plug-in. An implementation class is responsible for connecting to a data source and returning an ISchema implementation based on that structure. The purpose of the ISchema, ITable, and IRelationShip is abstracting a relational data structure. The ILanguageParser defines the contract for a language parser plug-in. An implementation class is responsible for parsing an ISchema implementation. The IPluginManager defines a contract for managing a collection of IPlugin implementations as you can see in the diagram above.

Using the code

A full code implementation is provided with the demonstration project. In order to improve your understanding of how the code works, I will show you a high level code implementation.

namespace CSharpParser
    public class CSharpParser : Worker.Core.API.ILanguageParser
        StringBuilder sb = new StringBuilder();
        public string Parse(Worker.Core.API.ISchema schema)
            //here you should write code to iterate 
            //throw the table and relationship collection. 

namespace SimpleConnector
    public class SimpleConnector : Worker.Core.API.IConnector
        public bool Connect(string pconnectionString)
        //here you should write code for data source connection.
        public Worker.Core.API.ISchema Buildschema(String pdataBase)
        //here you should write code for abstracting a relational data structure

namespace SimplePluginManager
    public class SimplePluginManager : Worker.Core.API.IPluginManager
        public List<IPLUGIN> GetAll()
        public object Find(string name)
        //here you should write code to find a plug in
        public object Plug(IPlugin plugin,String type)
            //here you should write code in order to bind 
            //the interface and its implementation.
        public bool Register(IPlugin info)
        //here you should write code for registering a plugin.
        public void Persist(String source)
        //here you should write code for persisting a plugin.
        public void Load(String source)
        //here you should write code for loading persisted plugins.

//Sample code usage
//Registering the plugins
IPluginManager pluginManager = 
  (IPluginManager)new SimplePluginManager.SimplePluginManager();
IPlugin pluginConnector = new Plugin();
pluginConnector.Name = "MySqlConnector";
pluginConnector.Path = @"MySqlPlugin\SimpleConnector.dll";
pluginConnector.Version = "1.0";
IPlugin pluginCSharp = new Plugin();
pluginCSharp.Name = "CSharpParser";
pluginCSharp.Path = @"CsharpPlugin\CSharpParser.dll";
pluginCSharp.Version = "1.0";

//Finding registered plugins
IPlugin fpluginConnector = 
IPlugin fpluginParser = (IPlugin)pluginManager.Find("CSharpParser");

//Connecting to a data source
IConnector con = 
//Creating the schema from a data source
Ischema schema = con.Buildschema("DataBaseName");
//generating the code
ILanguageParser parser = 
  (ILanguageParser)pluginManager.Plug(fpluginParser, "ILanguageParser");
this.richTextBox1.Text = parser.Parse(schema);


The Worker.API can be used to create code generators for any language. All you have to do is to create a plug-in and register it in a PluginManager. You can have your staff working in parallel. One writes the Connector while the other writes the LanguageParser.


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

Andre L.A.C Bittencourt
Web Developer
Brazil Brazil
He is a software developer based on Brazil. His main interests are Software architecture, Requirements Engineering and coding. He is a MCP and MCAD developer. If you want to get in contact, please send an e-mail to or access his company website

You may also be interested in...


Comments and Discussions

GeneralSimpleParser project missing in source Pin
Flemmingc18-Dec-06 10:10
memberFlemmingc18-Dec-06 10:10 
GeneralRe: SimpleParser project missing in source Pin
Andre Luiz de Alcantara Chaves Bittencourt26-Dec-06 15:36
memberAndre Luiz de Alcantara Chaves Bittencourt26-Dec-06 15:36 
GeneralRe: SimpleParser project missing in source Pin
Andre Luiz de Alcantara Chaves Bittencourt27-Dec-06 5:15
memberAndre Luiz de Alcantara Chaves Bittencourt27-Dec-06 5:15 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Praise Praise    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

Permalink | Advertise | Privacy | Terms of Use | Mobile
Web04 | 2.8.170915.1 | Last Updated 27 Dec 2006
Article Copyright 2006 by Andre L.A.C Bittencourt
Everything else Copyright © CodeProject, 1999-2017
Layout: fixed | fluid