---
title: "CORBA invocation methods and services"
subject: "Distributed System"
chapter: 4
key: "semester_7/distributed_system:corba-invocation-services"
source: https://www.bctengineer.com/q/semester_7/distributed_system/corba-invocation-services
site: BCT Engineering
---

# CORBA invocation methods and services

Distributed System · Chapter 4: Distributed Heterogeneous Applications and CORBA

- Asked in: 2074 Chaitra, 6 marks; 2074 Asoj, 2+4 marks; 2070 Asar, 2+4 marks (asked 3 times)
- Video: [CORBA Architecture | Part-1/2 | Distributed Systems | Lec-45 | Bhanu Priya](https://www.youtube.com/watch?v=aEOfsRKTlv0) — Education 4u
- Answer checked by Claude Opus 5.5 (high effort) on 2026-10-14
- Page: https://www.bctengineer.com/q/semester_7/distributed_system/corba-invocation-services
- Whole chapter: https://www.bctengineer.com/md/semester_7/distributed_system/chapter-4

## Question

Explain the CORBA invocation methods (dynamic and static invocation) with its services.

## Short answer

Static invocation uses IDL-generated stubs and skeletons with compile-time type checking; dynamic invocation (DII) builds requests at runtime via the Interface Repository, needing no stub. Both are supported by naming, trading, event, transaction, and security services. The ORB delivers requests, and the server cannot distinguish which method was used.

## Answer

CORBA (Common Object Request Broker Architecture) of the OMG lets objects written in different languages on different machines call each other through an Object Request Broker (ORB). A client can invoke an operation in two ways.

#### 1. Static invocation (stub based)
The interface is described in **IDL** and the IDL compiler generates a **client stub** and a **server skeleton**. The client links with the stub and calls it like a local method; the stub marshals the arguments, the ORB sends the request (via IIOP), and the skeleton unmarshals and calls the object implementation through the object adapter.
- Interface known at compile time, type checked, fast, simple.
- Less flexible: a new interface needs regenerated stubs.

#### 2. Dynamic invocation (DII)
The client builds the request at run time without a stub. It finds the interface from the **Interface Repository**, creates a Request object with operation name and arguments through the **Dynamic Invocation Interface** and sends it. On the server side the **Dynamic Skeleton Interface (DSI)** lets a server accept calls for interfaces unknown at compile time.
- Flexible: suited to browsers, gateways, tools and bridges.
- Slower and not type checked at compile time.

```text
 Client                          Server
+--------+  static  +-------+   +----------+  +--------+
| Client |--stub--->|       |-->| Skeleton |->|        |
|  code  |  DII --->|  ORB  |-->| DSI      |->| Object |
+--------+          +-------+   +----------+  +--------+
        (Interface Repository used by DII)
```

#### CORBA services supporting invocation
- **Naming service**: gets object references by name.
- **Trading service**: finds objects by property.
- **Event/notification service**: asynchronous, decoupled communication between suppliers and consumers.
- **Transaction service**: groups calls into atomic units.
- **Security service**: authentication and access control of invocations.
- **Life cycle, persistence, concurrency control** services for managing the objects invoked.

**Invocation modes:** synchronous (the client blocks for the reply) and one-way (no reply) work with both methods; deferred synchronous (send now, collect the reply later) is available through the DII.

Both methods give the same result; the server cannot tell which one the client used.

## Check yourself

The answer's key points as multiple-choice questions, with the correct option and why.

1. How does static invocation work?
   A. Client builds request at run time
   B. A stub generated from IDL marshals arguments; the skeleton calls the implementation
   C. No ORB is used
   D. Requests go only through the Interface Repository
   Answer: B. It is type checked and fast but the interface must be known at compile time. (Key point: Static invocation)

2. What does a client use for dynamic invocation?
   A. DII with the Interface Repository to build a Request object at run time
   B. Compiled stub only
   C. Skeleton
   D. Naming service only
   Answer: A. DII is flexible but slower and not compile-time type checked. (Key point: Dynamic invocation)

3. Which pair correctly contrasts the two methods?
   A. Static is slower; dynamic is type checked
   B. Static is fast and type checked; dynamic is flexible but slower
   C. Both need regenerated stubs for new interfaces
   D. Dynamic needs no repository
   Answer: B. Static needs regenerated stubs for new interfaces; dynamic doesn't. (Key point: Trade-off)

4. What does the Dynamic Skeleton Interface allow?
   A. Client to avoid ORB
   B. Faster marshalling
   C. A server to accept calls for interfaces unknown at compile time
   D. Stub generation
   Answer: C. DSI suits bridges and gateways. (Key point: DSI)

## Related in Distributed System

- [Object adapter and CORBA invocation](https://www.bctengineer.com/question.md?key=semester_7%2Fdistributed_system%3Aobject-adapter-invocation) — Distributed System, chapter 4
- [JINI goals, CORBA services, OS support](https://www.bctengineer.com/question.md?key=semester_7%2Fdistributed_system%3Aos-support-jini-corba) — Distributed System, chapter 3
- [Short note: CORBA services](https://www.bctengineer.com/question.md?key=semester_7%2Fdistributed_system%3Acorba-services-note) — Distributed System, chapter 4
- [CORBA services; object adapter functions](https://www.bctengineer.com/question.md?key=semester_7%2Fdistributed_system%3Acorba-services-object-adapter) — Distributed System, chapter 4
- [IDL and CORBA RMI with services](https://www.bctengineer.com/question.md?key=semester_7%2Fdistributed_system%3Aidl-corba-rmi) — Distributed System, chapter 4
- [Middleware role; CORBA and services](https://www.bctengineer.com/question.md?key=semester_7%2Fdistributed_system%3Amiddleware-corba-services) — Distributed System, chapter 4

## Related in other subjects

- [Static vs dynamic mathematical model](https://www.bctengineer.com/question.md?key=semester_8%2Fsimulation_and_modeling%3Astatic-vs-dynamic-math-model) — Simulation and Modeling, chapter 2, asked 3×
- [Static vs dynamic implementation of list](https://www.bctengineer.com/question.md?key=semester_4%2Fdata_structure_and_algorithm%3Astatic-vs-dynamic-list-example) — Data Structure and Algorithm, chapter 3, asked 2×
- [Static and dynamic hazards and their elimination](https://www.bctengineer.com/question.md?key=semester_3%2Fdigital_logic%3Astatic-dynamic-hazards) — Digital Logic, chapter 3, asked 2×
- [Static versus dynamic binding trade-offs](https://www.bctengineer.com/question.md?key=semester_3%2Fobject_oriented_programming%3Astatic-vs-dynamic-binding) — Object Oriented Programming, chapter 7
