IBM Rational Modeling Extension for Microsoft .NET enables .NET application developers to use Rational modeling tools in designing applications. This extension is available in IBM® Rational® Software Modeler, IBM® Rational® Systems Developer, and IBM® Rational Software Architect, and it includes support for modeling C# applications. This article, the first part in a series, describes modeling C# constructs and concepts using the C# profile and type library available in this extension. The examples here use that library to model these elements:

• Types
• Classes
• Structures (struct)
• Delegates
• Enumerations (enum)
• Fields
• Methods

To get started with modeling C# applications, you need to use the C# profile and type library provided by Rational Modeling Extension for .NET. To do this, you will follow these basic steps, which the following sections explain in more detail:

1. Create an empty UML model.
2. Import the C# primitive types library.
3. Apply the C# profile.

The C# primitive types library provides the basic primitive data types that are available in the C# language, such as long, byte, short, and so forth. The C# profile consists of various stereotypes that are applicable to UML classes, attributes, operations, and so on. By using those stereotypes, you can design C# constructs. Examples of stereotypes available in the profile are <<CSharpIndexer>> and <<CSharpDelegate>>.

Note:
General UML concepts, such as generalization, realization, and visibility, have the same meaning and are not explained in this article. However, Package visibility in UML maps to internal visibility in C#.

Step 1. Create a new model

Note:
The examples used here are only to illustrate the concepts and may not represent a real design for any application.

Start by designing a simple graphics library: To do this, create an empty model in a new UML project by using by the New UML Project wizard (Figure 1).

Step 2. Import the profile and type library

1. Now, in the Modeling perspective, select the model from the Project Explorer.
2. Right-click, and choose Import model library from the pop-up menu (Figure 2).

3. Choose C# Primitive Types from the Deployed Library list (Figure 3).

Step 3. Apply a C# profile

1. To apply a C# profile, select the model in the Project Explorer.
2. In the Properties view, select the Profiles tab and click Add profile .
3. Choose C# profile from the Deployed Profile list. (See Figure 4.)

Back to top

How to model various types

You can use Rational modeling extension to model various types, including classes, structs, delegates, and enumerations, among others. The following subsections describe the basic processes.

Modeling classes and interfaces

A C# sharp class is modeled simply as a UML class. However, to use C#-specific modifiers such as new, protected internal, static, and unsafe, you need to apply the <<CSharp class>> stereotype and set its property values. The example in Figure 5 uses a GraphicObject class with <<CSharp Class>> applied, just for the sake of illustration. Because we are not using any of the stereotype properties, we leave them at default values.

Note:
Use a stereotype from a C# profile only when you set at least one of the stereotype property values.

Similarly, a C# interface is modeled as a UML interface. Also, you can use a <<CSharp Interface>> stereotype if you need to use specific modifiers, such as new, protected internal, and unsafe.

Modeling structures

A C# structure (struct) is modeled as a UML class with the <<CSharp Struct>> stereotype applied. C#-specific modifiers, such as new, protected internal, and unsafe are available in the <<CSharp Struct>> as Boolean stereotype properties. The example in Figure 6 models a C# point structure with <<CSharp Struct>> applied.

Modeling delegates

A C# delegate is modeled as UML class with the <<CSharp Delegate>> applied to it. As with the struct type, C#-specific modifiers such new, protected internal, and unsafe are available as Boolean string properties. A UML class stereotyped as <<CSharp Delegate>> should not contain any attributes.

Also, in such a UML class, there should be a single UML operation with the same name as the delegate class. The signature of this operation should be same as the signature that would declared for its corresponding C# delegate. For the example in Figure 7, we modeled a C# delegate called <<handleResize>> by applying a <<CSharp Delegate>> stereotype to a UML class. This class has a UML operation named <<handleResize>> that takes two parameters of the Point type and returns a C# bool type.

To model the sample delegate:

1. First, create a UML class and name it handleResize.
2. Now apply the <<CSharp Delegate>> stereotype to it.
3. Add a UML operation, and name it handleResize.
4. Now select the newly added operation and, from Properties view, go to the Parameters tab and insert a new parameter.
5. Name this parameter start and set its direction as In ,and then from Browse type dialog, select Point struct as its type.
6. Add another parameter using the same process, and name it end.
7. Add another parameter, and set its direction as Return. Set its type as bool by browsing for the types from the imported CSharpPrimitiveTypes library.

Modeling enumerations

A C# enumeration (enum) is modeled as a UML enumeration. A <<CSharp Enum >> stereotype can be applied whenever you need to set the new or protected internal modifiers. This stereotype also allows you to specify an enumeration base type that is different from the implicit default. To do that, you need to set the stereotype implementation_type property in <<CSharp Enum >> to one of the listed enumeration base types, such as int, byte, or short. Optionally, the enumeration literals can have default integral values that represent the constant of the corresponding C# enumeration literal.

To model the sample enumeration:

1. First create a UML enumeration, and name it Colors.
2. Apply the <<CSharp Enum >> stereotype to it so that you can specify a different base type, such as short. The stereotype need not be applied if you do not want to set any of the stereotype properties.
3. Add an enumeration literal of RED, and set its value to 10.
4. Similarly add enumeration literals BLUE and GREEN, with values 20 and 30, respectively.

Modeling fields

A C# field is modeled as a UML property, thus either as a UML attribute or as an association end. Additionally <<CSharp Field >> stereotype can be applied whenever you need to set the new, protected internal, unsafe,volatile, and const modifiers. Other modifiers, such as static and readonly are available in the general properties section of a UML property.

A C# constant is modeled as a UML property with a <<CSharp Field >> stereotype and setting the Boolean stereotype property constant to true.

For this example, model sample fields and constants in the Point structure:

1. Create a UML attribute of X and, from the C# primitive type library, set its type to int as described previously.
2. Similarly, create another UML attribute of Y and set its type to int. This makes the two UML attributes X and Y, the C# fields.
3. To create a C# constant, add a UML ORIGIN_X attribute of type int, apply the <<CSharp Field >> stereotype, and set the stereotype property to constant=true.
4. Set the default value to 0.
5. Add another ORIGIN_Y constant of type int with a default value of 0, apply the same stereotype, and set the property to constant=true. Now, both ORIGIN_X and ORIGIN_Y represent C# constants. (See Figure 10.)

Modeling methods

A C# method is modeled as a UML operation with an optional <<CSharp Method>> stereotype. You need to apply the stereotype only if you want to set the modifiers, such as new, override, extern, virtual, protected internal, and unsafe. You can set other modifiers, such as abstract and static, in the general Properties section of a UML operation. If you need to set the sealed modifier on the method, select (enable) the Leaf property of the operation.

A void method is modeled as one with no return type. Set exceptions raised by a method this way:

1. Right-click a UML operation, and then go to the UML Properties menu.
2. Select the Raised Exceptions section, and insert the various exceptions.

For this example, model a simple C# method named displaywith a bool return type and a GraphicException. The method will take a parameter type of DrawingSurface.

1. Create two UML classes, DrawingSurface and GraphicException, to be used as a parameter type and exception type, respectively, for the sample method.
2. Create a public UML operation named display in the Point class, and, from the C# primitive type library, set its return type to bool as described previously.
3. Add a parameter named surface to the operation, and set its type to DrawingSurface.
4. In the Project Explorer, right-click the UML operation, and then select the UML Properties menu.
5. Go to the RaisedException section, and click Insert to insert a new exception type.
6. Select the GraphicException class as the exception to add. (See Figure 11 and Figure 12.)

Back to top

What's next

This article described how to use the C# profile and type library in Rational Modeling Extension for Microsoft .NET. After completing these exercises, you should be able to create simple models containing C# classes, structs, delegates, interfaces, enums , fields, and methods. Part 2 of this series explains modeling C# indexers, properties, constructors, destructors, and operators.

Resources

Learn

• Modeling C# applications using Rational Modeling Extension for .NET, Part 2 by Rajeshwari Rajendra, is the second article in this two-part series. (IBM® developerWorks®, November 2007).
  
  
• Visit the IBM Rational Modeling Extension for Microsoft .NET area on developerWorks for technical documentation, how-to articles, education, downloads, and product information.
  
  
• Visit the Rational Software Architect area on developerWorks for technical documentation, how-to articles, education, downloads, and product information.
  
  
• Subscribe to the developerWorks Rational zone newsletter. Keep up with developerWorks Rational content. Every other week, you'll receive updates on the latest technical resources and best practices for the Rational Software Delivery Platform.
  
  
• Browse the technology bookstore for books on these and other technical topics.
  
  

Get products and technologies

• Download trial versions of IBM Rational software.
  
  
• Download the trial version of Rational Modeling Extension for MS .NET.
  
  
• Download IBM product evaluation versions and get your hands on application development tools and middleware products from DB2®, Lotus®, Rational®, Tivoli®, and WebSphere®.
  
  

Discuss

• Check out developerWorks blogs and get involved in the developerWorks community.
  
  
• Rational Software Architect, Data Architect, Software Modeler, Application Developer and Web Developer forum: Ask questions about Rational Software Architect.
  
  

About the author

Rajeshwari Rajendra is a software engineer in the IBM India Software Lab, working on the Rational Systems Developer team. Her expertise includes XML query technologies, such as XPath and XQuery, and UML modeling and transformations (specifically, C# and C++). She has a Master's degree (MCA) from Bangalore University, India.

Rate this article

Comments

Back to top

Table of contents

• Step 1. Create a new model
• Step 2. Import the profile and type library
• Step 3. Apply a C# profile
• How to model various types
• What's next
• Resources
• About the author
• Comments

Next steps from IBM

• Try: Rational Software Architect
• Buy: Rational Software Architect

Dig deeper into Rational on developerWorks

Try IBM PureSystems. No charge.

Experience today!

---

Get started with the cloud-based trial and pattern development kit.

Special offers