Richard Wiener

Remoting in C# and .NET.

This is the first in a series of tutorial columns that shall deal with specialized aspects of C# programming and the .NET framework. The .NET Remoting API is the equivalent of the Java Remote Method Invocation (RMI) API. Both frameworks allow objects on a client machine to communicate with remote objects on a server. To me, the infrastructure required in .NET appears simpler than in Javas RMI. What makes Remoting (or equivalently RMI) so attractive is that the low-level socket protocol that the programmer must normally manage is abstracted out. The programmer is able to operate at a much higher and simpler level of abstraction. In both languages there is some overhead in the form of boilerplate protocols that must be observed in order to setup the handshaking between the client and server machines. Once this is done, sending a message from a client machine to a server object uses the same syntax as sending a message to a local object. The metaphor of object-oriented programming remains central to this distributed programming. My last column presented a distributed solution to the Traveling Salesperson Problem (see this column in the Nov/Dec, 2003 issue of JOT) using Javas RMI. Although it is tempting to present a detailed and exhaustive presentation of .NETs distributed computing protocol, space does not permit this here. In this column, only an introduction and several simple examples of .NET Remoting using C# are presented. The namespaces that one typically uses in C# distributed object applications are the following: When using one of the major IDEs (Visual Studio or C# Builder), it is important to add the reference system.remoting.dll to your build if it is not already present.

Branch and Bound Implementations for the Traveling Salesperson Problem - Part 2: Single threaded solution with many inexpensive nodes.

In the first column published in the March/April, 2003 issue, a branch and bound algorithm that involves generating nodes that represent partial tours with constraints was presented and implemented. The computational cost as well as the memory overhead required to generate each node was shown to be significant. Furthermore, the algorithm assumes that the cost matrix that specifies the cost of traveling from one city to another is symmetric. All of these problems are overcome using the algorithm to be presented and implemented in this column.

WCF: A Case Study Involving a Distributed Client/Server Game.

WCF provides a basis for SOA – service-oriented architecture. This paradigm differs from traditional OOP in which tight encapsulation of data is encouraged and supported by classes. With SOA utilizes loosely coupled services. Each service defines a contract to the entities that consume it. It is generally difficult to implement a single interface across many platforms and languages because of the nature of distributed systems. It is essential to implement the interfaces in a generic manner.

Arithmetic Function Interpreter in C# 3.0 Using Lambda Expression Trees.

Here the first generic parameter indicates that the independent variable, x, is of type double and the second generic parameter, of type double, is the return type. In general a lambda expression is written as a parameter list, followed by the => token, followed by an expression or a statement block. Expression trees, another new C# 3.0 feature, allow lambda expressions to be represented as data structures instead of executable code. Expression trees are “efficient in-memory data representations of lambda expressions and make the structure of the expression transparent and explicit” (Microsoft C# 3.0 Specifications -http://msdn2.microsoft.com/en-us/library/ms364047(vs.80).aspx#cs3spec_topic9 ). An expression tree could be defined as follows:

Delegates and Events in C

Delegates are a feature of C# not found in Java. A delegate is a class that encapsulates a method signature. Although it can be used in any context, it often serves as the basis for the event-handling model in C# but can be used in a context removed from event handling (e.g. passing a method to a method through a delegate parameter). Delegates provide a type-safe, object-oriented mechanism for treating functions as objects and passing method references as parameters without having to use function pointers as in C or C++. Since delegates are classes, they have instances (delegate objects). Such delegate instances contain references to one or more methods. A delegate instance is connected to one or more methods using a delegate constructor and later using simple operators. The methods that a delegate instance is associated with (invocation list) are invoked through the delegate instance. Delegates play a central role throughout the .NET framework and provide the basis for event handling so it is important to acquire a solid understanding of how they work and how they can be used. A delegate defines the signature (return type and sequence of parameter types) of the methods that can be added to the invocation list of a delegate instance. If an attempt is made to add a method to a delegate objects invocation list that does not confirm precisely to the signature in the delegate class, a compilation error is emitted. An example of a delegate class declaration is the following: Instances of a delegate class are created as indicated in the following examples: SomeDelegate d1 = new SomeDelegate(Method1); SomeDelegate d2 = new SomeDelegate(Method2);

Darwin's World Simulation in C#: The Model/View Classes.

Please refer to the paper, “Darwin’s World Simulation in C#: An Interpreter” from the January/February, 2010 issue of JOT. This paper focuses on the GUI aspects of the implementation. The two remaining classes are World (the model of the Darwin world) and the GUI class WorldUI. The World classs communicates to the WorldUI class, the observer class, by firing events. This model/view separation provides for easier maintenance. Class World is presented below.

Darwin's World Simulation in C#: An Interpreter.

In Darwin’s world the user creates robot-like graphical creatures with behavior defined by a simple programming language. These creatures migrate around a small two-dimensional grid, each according to its simple program created by the user. The GUI application that controls and displays the location of these creatures must interpret the program instructions supplied in a simple text file for each creature type in real-time and display the movement and behavior of these creatures. Since some creatures may “infect” another creature in an adjacent grid location, converting the infected creature into the same type as the creature administering the infection, the population of the various creature types changes over time although the total number of creatures remains constant. The application tracks and displays the population dynamics as the simulation evolves. New creature types may be created by supplying a text file that contains the “program” that the application interprets. This necessitates changes to the GUI that displays the dynamics of the simulation.

Ant Colony System Optimization.

Successful heuristic algorithms for solving combinatorial optimization problems have mimicked processes observed in nature. Two highly successful families of algorithms that do this are simulated annealing and genetic algorithms. Here, a third family of algorithms, ant colony optimization is explored and implemented in C#. The test bed for evaluating the quality of solutions is based on several Traveling Salesperson Problems (TSP) of varying size using real-world data (Euclidian problems) with known solutions.

A New Software Development Project Using an Old Game.

As many of us who teach more advanced programming courses know, finding software development projects that are engaging to students and that provide sufficient richness to allow for interesting designs and implementations while being solvable within the timeconstraints of a semester is challenging. Some games provide a basis for satisfying these requirements since they do not require prior domain expertise. The rules can be specified precisely in contrast to many real-world problems where only fuzzy and changing specifications are the norm.

A Pedagogical Experiment: Introducing Students to a First GUI Project Using C#/.NET.

The project to be described in this paper is being presented to a group of 26 students in a course that deals with modern software development using C#/.NET(and using a book soon to be published with the same title “Modern Software Development Using C#/.NET” by Richard Wiener, 711 pages, Thompson Course Technology, April, 2006. The students are new to the C# language and the .NET framework but have prior experience with Java as their first programming language, studied in CS 1 and CS 2. Most of the students have little or no experience constructing a GUI application.