<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html lang="en-us" xml:lang="en-us">
<head>
<meta content="text/html; charset=utf-8" http-equiv="Content-Type" />
<meta name="copyright" content="Copyright (c) 2000, 2006 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html. Contributors: IBM Corporation - initial API and implementation" />
<meta name="DC.rights.owner" content="(C) Copyright 2000, 2006" />
<meta content="public" name="security" />
<meta content="index,follow" name="Robots" />
<meta http-equiv="PICS-Label" content='(PICS-1.1 "http://www.icra.org/ratingsv02.html" l gen true r (cz 1 lz 1 nz 1 oz 1 vz 1) "http://www.rsac.org/ratingsv01.html" l gen true r (n 0 s 0 v 0 l 0) "http://www.classify.org/safesurf/" l gen true r (SS~~000 1))' />
<meta content="task" name="DC.Type" />
<meta name="DC.Title" content="Adding a message" />
<meta name="abstract" content="Messages represent an abstract definition of the data being transmitted. A message consists of logical parts, each of which is associated with a definition within some type system. WSDL messages are top level objects that can be referenced by an operation's input, output and fault elements (within a port type)." />
<meta name="description" content="Messages represent an abstract definition of the data being transmitted. A message consists of logical parts, each of which is associated with a definition within some type system. WSDL messages are top level objects that can be referenced by an operation's input, output and fault elements (within a port type)." />
<meta content="WSDL, adding messages, Web services, adding WSDL messages" name="DC.subject" />
<meta content="WSDL, adding messages, Web services, adding WSDL messages" name="keywords" />
<meta scheme="URI" name="DC.Relation" content="../concepts/cwsdled.html" />
<meta scheme="URI" name="DC.Relation" content="tcrtwsdl.html" />
<meta scheme="URI" name="DC.Relation" content="tedtwsdl.html" />
<meta content="XHTML" name="DC.Format" />
<meta content="taddmess" name="DC.Identifier" />
<meta content="en-us" name="DC.Language" />
<link href="../../org.eclipse.wst.doc.user/common.css" type="text/css" rel="stylesheet" />
<title>Adding a message</title>
</head>
<body id="taddmess"><a name="taddmess"><!-- --></a>


<h1 class="topictitle1">Adding a message</h1>



<div><p>Messages represent an abstract definition of the data being transmitted.
A message consists of logical parts, each of which is associated with a definition
within some type system. WSDL messages are top level objects that can be referenced
by an operation's input, output and fault elements (within a port type).</p>

<div class="section"><p>You can create a message using the Outline view by right-clicking
the <strong>Messages</strong> folder and clicking <strong>Add Message</strong>.</p>
<p>If you want
to create a new message for your input, output, or fault element, follow these
steps:  </p>
</div>

<ol>
<li class="stepexpand"><span>In the Design view, right-click your input, output, or fault element
and click  <strong>Set Message &gt; New Message.</strong></span></li>

<li class="stepexpand"><span>Type the name of the message in dialog.</span> This name should
be a unique amongst all messages defined within the enclosing WSDL document.
Click <strong>OK</strong>.</li>

<li class="stepexpand"><span>The new message will appear in the Design view within the port
type.</span></li>

</ol>

<div class="section"><p> <strong>Note</strong>: Messages are referenced within a port type (specifically
by an operation's input, output and fault objects). The input, output and
fault objects within a binding do not reference messages. Hence you cannot
create a new message by right clicking on a input, output, or fault within
a binding (these are also known as binding input, binding output and binding
faults).</p>
<p> <strong>Tip</strong>: You can also create a new message for your input,
output, or fault element using the Outline view. Under the  <strong>Port Types</strong> folder,
right-click your element and click  <strong>Set Message &gt; Add Message</strong>. Your
message will appear in the Outline view under the  <strong>Messages</strong> folder.</p>
<p>If
you want to reuse a message for your input, output, or fault element, follow
these steps:</p>
<ol>
<li>In the Design view, right-click your input, output, or fault element and
click  <strong>Set Message &gt; Existing Message.</strong></li>

<li>In the <strong>Name</strong> field, type a search string to filter the list or leave
the field blank to view all.</li>

<li>You can change the scope of the list by selecting one of the following
options:<ul>
<li><strong>Workspace</strong>. Lists the messages available in your workspace.</li>

<li><strong>Enclosing Project</strong>. Lists the messages available in the project
that contains your file.</li>

<li><strong>Current Resource</strong>. Lists the messages available in your current
file.</li>

<li><strong>Working Sets</strong>. Lists the messages available in a specified set of
files. To specify a working set, click <strong>Choose</strong>. You can select files
from an existing working set or create a new working set. Once you have selected
the files, click <strong>OK</strong>.</li>

</ul>
</li>

<li>The existing messages will be listed. Select one and click  <strong>OK</strong>.</li>

</ol>
<p>If you want to import an existing message for your input, output,
or fault element, follow these steps:</p>
<ol>
<li>In the Design view, right-click your input, output, or fault element and
click  <strong>Set Message &gt; Existing Message.</strong></li>

<li>In the <strong>Name</strong> field, type a search string to filter the list or leave
the field blank to view all.</li>

<li>You can import a message by selecting one of the following options:<ul>
<li><strong>Workspace</strong>. Lists the messages available in your workspace.</li>

<li><strong>Enclosing Project</strong>. Lists the messages available in the project
that contains your file.</li>

<li><strong>Working Sets</strong>. Lists the messages available in a specified set of
files. To specify a working set, click <strong>Choose</strong>. You can select files
from an existing working set or create a new working set. Once you have selected
the files, click <strong>OK</strong>.</li>

</ul>
</li>

<li>The messages will be listed. Select one and click <strong>OK</strong>.</li>

</ol>
<p>You can now add parts to your message. Parts are a flexible mechanism
for describing the logical abstract content of a message.</p>
</div>

</div>

<div>
<div class="linklist"><strong>Related concepts</strong><br />

<div><a href="../concepts/cwsdled.html" title="The WSDL editor allows you to easily and graphically create, modify, view, and validate WSDL files.">Editing WSDL files with the WSDL Editor</a></div></div>

<div class="linklist"><strong>Related tasks</strong><br />

<div><a href="tcrtwsdl.html" title="You can create a new, empty WSDL file, then edit it using the WSDL editor.">Creating a new WSDL file</a></div>
<div><a href="tedtwsdl.html" title="Once you have created a WSDL file, you can edit it in the WSDL editor. You can also import WSDL files you have created into the workbench and edit them in the WSDL editor.">Editing WSDL files</a></div></div>
</div>

</body>
</html>