NOTE: This file is no longer being updated. See the CHANGES file in
      the top-level directory.


Changes since version 3.2.0
---------------------------

- Added demo book/lifecycle.

- Fixed object adapter activation deadlock. The deadlock could occur
  when the adapter register its endpoints with the locator registry
  and if another thread invokes concurrently on the locator.
  
- Added support for protected class data members using the new
  metadata tag ["protected"]. The tag can be applied to a Slice class
  or to individual data members.

- Changed the throughput demo to better support cross-language
  testing.

- Fixed throughput performance problem on Windows that would occur
  when sending large requests.

- Added Ice.TCP.RcvSize and Ice.TCP.SndSize properties. These
  properties control the size of the TCP receive and send buffers for
  the TCP and SSL transports.

- Added support for opaque endpoints. For example:

  opaque -t 2 -v CTEyNy4wLjAuMREnAAD/////AA==

  This is the same as:

  ssl -h 127.0.0.1 -p 10001

  The "opaque" protocol identifier indicates an unknown protocol.
  Both the -t and the -v option must be present:

  -t <num>:    Indicates the protocol type (TCP = 1, SSL = 2, UDP = 3).

  -v <base64>: Provides the value of the opaque endpoint. The option
               argument is the marshaled representation of the endpoint
               (including the endpoint's enclosing encapsulation) in
               base64 encoding.

  This syntax is useful if, for example, a client that has the SSL
  plug-in configured sends a proxy with an SSL endpoint to a server
  without the SSL plug-in. Prior to this version, the server would
  drop the unknown SSL endpoint when it stringified the proxy.
  As of this version, the server preserves the endpoint and, when the server
  stringifies a proxy containing an unknown endpoint, it uses the above opaque syntax.

- Trailing characters past the adapter id in a stringified proxy
  will now raise a ProxyParseException.

- Fixed the translator to correctly generate marhsaling/unmarshaling
  methods for interfaces and allow them to be transfered by value.

Changes since version 3.1.1
---------------------------     

- createObjectAdapter() and propertyToProxy() print warnings if
  unknown properties are found during creation of the adapter or
  proxy. These warnings can be disabled by setting the property
  Ice.Warn.UnknownProperties=0.

- Added the property Ice.Default.EndpointSelection. If not defined,
  the default value is "Random".

- Proxies and object adapters can now be configured to use
  thread-per-connection.

- IceBox services no longer inherit the properties of the container
  by default. If this is the desired behavior set the property
  IceBox.InheritProperties to 1.

- The exception mapping now provides "one-shot" constructors that
  permit the data members of an exception to be initialized during
  construction (similar to the way class members can be initialized
  during construction).

  With this new mapping, the "Message" property of the base class
  System.ApplicationException can no longer be set; the property is
  initialized to the empty string. See the Ice Manual for more
  details.

- Ice run-time threads are now created with the IsBackground property
  set to true. This prevents Ice processes from hanging if an
  application calls Environment.Exit() without first shutting down the
  Ice run time.

- Modified the IceSSL configuration to allow the demos and most tests
  to run without administrator privileges.

- Added Communicator::isShutdown() and ObjectAdapter::isDeactivated()
  to allow applications to determine whether a communicator has been
  shutdown or an object adapter has been deactivated, respectively.

- Added destroy() operation to the ObjectAdapter interface. This
  operation must be called in order to reclaim the adapter's resources
  and be able to recreate a new adapter with the same name. Destroying
  a communicator automatically calls destroy on all of its adapters.

- Added a per-process logger and two methods to get/set the logger,
  Ice.Util.getProcessLogger() and Ice.Util.setProcessLogger(). Calling
  getProcessLogger() creates a default logger if setProcessLogger()
  has not been called. The process logger is also used as the default
  logger for all communicators that do not have a logger explicitly
  set.

- Fixed a bug in the plug-in property parsing code: if the file name of
  a plug-in included a drive letter, the plug-in did not load.

- Added support for a user-defined signal handler in Ice.Application.
  A subclass must override the interruptCallback method and invoke
  callbackOnInterrupt to activate it.

- Message batches are now automatically flushed when the total size of
  the batch reaches the message size maximum. This feature can be
  controlled using the Ice.BatchAutoFlush property, which is on by
  default.

- During the creation of an object adapter, the communicator now
  raises InitializationException if the adapter has no configuration.
  It is possible to create an adapter with no configuration, which
  is useful for bidirectional connections, by passing an empty string
  as the argument to createObjectAdapter.

- Fixed a bug that could cause the marshaling code to assert
  if Ice.MessageSizeMax was exceeded during marshaling of a string.

- It is now possible to start and stop individual IceBox services
  using the IceBox admin utility.

- Added Communicator::propertyToProxy() which creates a proxy from
  a set of properties. This operation allows you to set various local
  proxy settings, such as the locator cache timeout, which cannot be
  set using stringToProxy().

- The Ice.Logger.Timestamp property has been removed. Timestamps are
  now always printed.

- Added the property Ice.Default.PreferSecure, which if set to 1
  causes secure endpoints to be preferred over non-secure endpoints.
  By default this property is set to 0. Also added functions to
  control this behavior on a per-proxy rather than global basis:
  ice_isPreferSecure() and ice_preferSecure().

- Added a demo to illustrate use of AMI/AMD.

- IceBox services are now stopped in the reverse order from which they 
  were started.

- If a proxy does not specify a hostname (via -h HOST), the client
  only attempts to connect to the loopback interface (127.0.0.1).

- Attempts to change the attributes of a fixed proxy now result in a
  FixedProxyException rather than just ignoring the change request and
  returning the same proxy. Also, attempts to marshal a fixed proxy
  now result in a FixedProxyException rather than a MarshalException.

- Added support for implicit request contexts. When you invoke an
  operation on a proxy and don't pass an explicit context, Ice uses
  the "implicit context" combined with the per-proxy context (if any).
  You can obtain the implicit context using the new communicator
  operation getImplicitContext(). Three implementations of implicit
  context are available; you select one by setting the property
  Ice.ImplicitContext to one of the following values:

  * None: No implicit context at all (default).
  * PerThread: The implementation maintains a context per thread.
  * Shared: The implementation maintains a single thread-safe context
    that is shared by all threads.

- Removed defaultContext from InitializationData.

- Communicator::setDefaultContext(), Communicator::getDefaultContext()
  and Proxy::ice_defaultContext() have been deprecated.

- For object adapters without endpoints, Ice.Trace.Network >= 2 now
  prints a trace message.

- Added Ice.Override.Secure which forces a client to only use
  secure connections.

- Added more tracing to the IceSSL plug-in to aid in using the
  TrustOnly properties.

- Removed support for the IceBox.ServiceManager.Identity property,
  which was deprecated in Ice 3.0. The IceBox service supports an
  InstanceName property that should be used instead.

- Added UnexpectedObjectException. This exception is raised if you
  use Slice classes and client and server are compiled with mismatched
  Slice definitions. Alternatively, this exception is raised if you
  use dynamic invocation and pass a class of the wrong type as an
  operation parameter.

- Passing null for a sequence parameter mapped as a collection (i.e.,
  using "clr:collection" metadata) no longer results in a
  NullReferenceException but instead causes an empty sequence to be
  sent.

- Fixed a bug where loading an Ice plug-in or an IceBox service could
  result in a System.NullReferenceException if no constructors are
  available to create the plug-in or service instance.

- New Slice metadata for operations:

  - ["nonmutating"] provides backward compatibility for idempotent
    operations that were previously declared using the deprecated
    'nonmutating' keyword. You can replace the 'nonmutating' keyword
    with '["nonmutating"] idempotent' to maintain compatibility with
    objects implemented using Ice 3.0 or 3.1.

Changes since version 3.1.0
---------------------------

- Fixed a bug with the IceGrid allocate and sessionAllocation demos
  where the session would not be destroyed in the event of an
  allocation failure.

- Restored Communicator::setDefaultContext.

Changes since version 3.0.1
---------------------------

- Removed removeObjectFactory() from the communicator interface.

- Added an IceSSL plug-in for .NET 2.0. See the Ice manual for more
  information.

- ObjectAdapter::deactivate() now notifies the locator registry when
  the adapter is deactivated.

- Fixed ObjectAdapter::activate() to activate the object adapter
  only if it is able to register its endpoints and process proxy with
  the locator. Calling activate() again retries a failed registration.

- Generating new streaming functions for a Slice structure. The
  ice_write and ice_read member functions replace their internal
  equivalents (__write and __read).

- Removed getDefaultProperties() functions, and the global default
  properties. If you need global properties, you can easily create
  your own global variable.

- Added new createProperties() method:

  public static Properties 
  createProperties(ref string[] args, Properties defaults)
 
  where "defaults" represents an optional set of default properties
  used to initialize the new Properties object. Ice properties 
  defined on the command line and properties defined in a
  configuration file override these default properties.

- Fixed a bug where the proxy timeout, compress flag and connection
  id attributes would be ignored for direct proxies using a router.

- Added ability to configure Ice thread start/stop hooks through
  InitializationData.

- Added identityToString and stringToIdentity to the Communicator
  interface.

- It is now possible to recreate a new object adapter with the same 
  name as an old adapter once waitForDeactivate() has completed on the
  old adapter.

- Added new operation Communicator::createObjectAdapterWithRouter(),
  which creates a routed object adapter. An object adapter may now
  be associated with at most one router, which is defined using this
  operation or by setting the <AdapterName>.Router property. Also
  as a result of this change, the ObjectAdapter::addRouter() and
  ObjectAdapter::removeRouter() operations have been removed.

- Added communicator initialize functions that take an argument of
  type Ice.InitializationData. This class contains communicator
  members that may only be set during communicator initialization.
  Currently included are Properties, Logger, Stats, default context
  and the thread hooks. The initializeWithXXX functions have been
  deprecated and the setLogger(), setStats() and setDefaultContext()
  operations have been removed.

- Added the new Slice metadata "deprecate" that can be used to
  qualify operations. The Slice-to-C# compiler translates this
  into an equivalent attribute in the generated code.

- Added a new operation addProxies() to Ice::Router, which can return
  evicted proxies. The old operation addProxy() is now deprecated.
  Note that this is an internal interface for communications between
  clients and routers (such as Glacier2).

- Fixed a bug where the ice_locator proxy method wouldn't change the
  proxy locator.

- The ice_timeout and ice_compress proxy methods now correctly
  override the timeout and compress flag of indirect proxy endpoints.

- Added proxy methods ice_isSecure, ice_getLocator, ice_getRouter,
  ice_isCollocationOptimized.

- Deprecated the following proxy methods:

  ice_hash
  ice_communicator
  ice_collocationOptimization
  ice_connection
  ice_newIdentity
  ice_newFacet
  ice_newContext
  ice_newAdapterId
  ice_newEndpoints

  These methods will be removed in the next major release. You should
  use the new methods shown below:

  ice_getHash
  ice_getCommunicator
  ice_collocationOptimized
  ice_getConnection
  ice_identity
  ice_facet
  ice_context
  ice_adapterId
  ice_endpoints

- Added requestId to Current, which allows a servant to determine
  whether an operation was invoked with collocated, oneway or twoway
  semantics. The requestId member is 0 for oneway invocations and
  -1 for collocated invocations.

- AMI invocations will now reuse the connection cached with the
  proxy instead of always looking up an existing connection for
  each invocation. As a side effect of this change, AMI invocations 
  on a proxy with collocation optimization enabled will now raise
  Ice::CollocationOptimizationException.

- Added the property Ice.Default.LocatorCacheTimeout and the proxy
  method ice_locatorCacheTimeout(). If a cached endpoint is older
  than the configured cache timeout, the Ice runtime won't use
  the cached endpoint. Instead, the Ice runtime will query the
  Ice locator service to retrieve up-to-date endpoints and then update
  the locator cache. Please see the Ice manual for more information.

- Added the proxy method ice_endpointSelection, which allows an
  application to control how endpoints are selected at connection
  establishment. Two endpoint selection types are currently supported:
  Random and Ordered.

- Added the proxy method ice_connectionCached. This method allows you
  to enable or disable the caching of the connection by the proxy. By
  default, the proxy will cache the connection to avoid looking it up
  for each request. Disabling the connection caching is useful to do
  per-request load balancing: the proxy will select a connection for
  each request and the request will eventually be sent to different 
  servers.

- Performance improvements if an AMI callback object is reused with 
  the same proxy.

- If several proxies share the same connection, and an operation call
  on one of the proxies causes a failure and the shared connection to
  be closed, then subsequent calls on the other proxies will try to
  establish a new connection instead of throwing an exception, even if
  retries are disabled.

- Fixed bug in the unmarshaling code for sequences of classes
  that use the ["clr:collection"] metadata directive:
  if such a class sequence contained null references, the client
  could not unmarshal the sequence.

- Fixed bug in identityToString() and proxyToString() that could
  cause incorrect string values to be returned for identities
  containing characters outside the ASCII range or for characters
  that must be escaped, such as '/'.

- If a proxy is not configured with a -h parameter, Ice will now
  attempt to connect using all local interfaces. The loopback interface 
  (127.0.0.1) will only be tried if it is the only local interface present.

- .NET 2.0 is now the target for All.sln. To build a version of Ice
  for C# that is compatible with .NET 1.1, use All_11.sln instead.

- Added the "clr:property" directive for classes and structures.
  If used, the property causes Slice data members to be mapped
  to properties instead.

- createReverseProxy() did not use the default context established
  on the communicator and created a proxy with an empty context
  instead. This has been fixed.

Changes since version 3.0.0
---------------------------

- Fixed a bug in the treatment of default contexts: proxies were
  created with an empty context instead of the default context on the
  communicator in some cases.

- Fixed a bug in the code generator that caused Clone() on sequences
  and dictionaries to behave incorrectly.

- Fixed a bug in the code generator that could cause Equals()
  comparisons to fail for containers that contained null references.

- Added ProxyIdentityKey and ProxyIdentityFacetKey helper classes to
  allow proxies to be inserted into collections and use only the
  identity, or the identity and facet name as the key. (See section
  14.11.3 in the doc.)

- Fixed a bug in endpoint comparisons that would cause new connections
  to be created needlessly. This would occur when the representation
  of the host differed between the proxy and endpoint configuration,
  with one containing the hostname and the other the numeric host
  address.

- Fixed a bug in the marshaling code that caused an exception if a
  null reference for a Slice class was passed as a parameter.

- Fixed a bug in the Slice parser that caused problems if an included
  file contained white space in the file name.

- Fixed a bug in slice2cs that prevented the generated code from being
  marked as CLS-compliant if the --checksum option was used.

Changes since version 2.1.2
---------------------------

- Fixed a deadlock during shutdown that could happen with
  bi-directional connections.

- Changed the mapping for Slice structures: if a Slice structure
  (recursively) contains a member that is of reference type, the Slice
  structure automatically maps to a C# class.

  A Slice structure now maps to a C# structure only if the Slice
  structure (recursively) consists only of value type (and if the
  "clr:class" metadata directive does not apply to the structure).

- Removed ice_default() method from proxies.

- Added an implementation of IceBox for C#.

- Fixed bug in Ice.Application that could cause appName() to return
  the empty string in some cases.

- The run time was obscuring the true origin (source file and
  line number) of some exceptions when rethrowing them. It
  now correctly shows the source of such exceptions
  in the stack trace.

- Connection::close(false) (i.e., graceful connection shutdown) now
  waits until all outstanding requests have completed.

- Added a new object adapter property, <adapter>.ReplicaGroupId, which
  allows adapters to be replicated. See the IceGrid chapter in the
  manual for more information.

- Added the proxy method ice_connectionId, which allows an application
  to control connection reuse.

- Added the new methods Ice.Util.initializeWithLogger() and
  Ice.Util.initializeWithPropertiesAndLogger(), which ensure that a
  custom logger is used to record any errors during communicator
  initialization.

- Ice will now listen on all local interfaces if no -h parameter is
  present in the endpoint configuration and no default host has been
  set. It will also listen to all interfaces if the -h parameter is
  set to 0.0.0.0. In such configurations the endpoints published in
  proxies will not contain the loopback interface (127.0.0.1) unless
  it is the only local interface present.

- The Equals method for Slice structures that are mapped to classes
  now returns false if the two structures being compared are not of
  the same type.

  Previously, a comparison such as

      derived.Equals(base)

  returned true if the base of part of derived was the same as base;
  with the new slice2cs compiler, this comparison returns false.

- The Slice mapping for sequences has been improved. The generated
  sequence class now contains the following additional properties and
  methods:

  - Capacity
  - TrimToSize
  - Sort
  - Reverse
  - BinarySearch
  - InsertRange
  - RemoveRange
  - GetRange
  - SetRange
  - LastIndexOf
  - Repeat

  These have the same semantics as the corresponding methods on
  System.Collections.ArrayList, with one exception: GetRange returns a
  true copy of the requested range instead of returning a view of a
  sub-section of the collection.

- The Ice run-time libraries are now marked as CLS-compliant
  assemblies. In addition, the generated code is now also
  CLS-compliant.

  This involves one change to the C# language mapping:

  The skeleton class used be called _<interface-name>Disp but is now
  called <interface-name>Disp_.

  For example, if you previously had:

      class MyIntfI : _MyIntfDisp { /* ... */ }

  you now have to write:

      class MyIntfI : MyIntfDisp_ { /* ... */ }

  Similarly, for the Tie mapping, the location of the underscore has
  changed:

      _MyIntfTie -> MyIntfTie_

- Added support for the thread-per-connection concurrency model.

- Changed the way servant locators work if a server has a servant
  locator registered for a specific category, in addition to a default
  servant locator. Previously, if the locator for the specific
  category failed to locate the servant, the run time would then call
  the default locator. With the new behavior, if the locator for the
  specific category does not return a servant, the default locator is
  not called.

- slice2cs now supports a new metadata directive: ["cs:attribute"].
  This directive allows you to inject C# attribute definitions into
  the generated code. See the C# mapping chapter in the Ice manual for
  more information.

- Added proxy methods to retrieve the proxy adapter id and endpoints
  (ice_getAdapterId() and ice_getEndpoints()) and to create a new
  proxy with a new adapter id or new endpoints (ice_newAdapterId() and
  ice_newEndpoints()).

- Fixed a bug that would cause UDP server connections to be closed on
  transient errors, thus preventing the reception of any more UDP
  messages until a server restart.

- Communicator::setDefaultContext() no longer changes the context
  information set on existing proxies.

- Ice.Communicator.createObjectAdapter() throws
  Ice.AlreadyRegisteredException if it is called with the name of an
  object adapter that already exists.

- The "cs:" metadata prefix has been replaced by the "clr:" prefix, so
  you now need to use "clr:collection" and "clr:class".  The "cs:"
  prefix is still recognized and acted upon; slice2cs emits a warning
  for the old prefix. Two releases from now, the warning will become a
  hard error and "cs:" will no longer work.

- Fixed a bug in the slice2cs code generator: for sequences of Slice
  structs that used the class mapping, the generated code caused a
  run-time error.

- Fixed a bug in the slice2cs code generator: if an operation had a
  parameter named i or szx, incorrect code was generated in some
  cases.

- Renamed CompressionNotSupportException to a more general
  FeatureNotSupportedException.

- Added ice_communicator() to proxies. This function returns the
  communicator that was used to create the proxy.

- Added ice_toString() to proxies. This function returns the
  stringified proxy. This function can be more convenient to use than
  communicator.stringToProxy() because you do not need the
  communicator to stringify a proxy that way.

- Parsing a stringified proxy no longer completely fails if the proxy
  contains an endpoint type that is unknown to the Ice runtime as long
  as the proxy contains other endpoints that are known. A warning is
  printed for the unknown types that are encountered.

- Ice.ObjectImpl is now an abstract class that cannot be instantiated.
  This change should be transparent to application code.

- Added new features to the C# mapping:

  - Structures, classes, and exceptions now have one-shot
    constructors. For example, for a class

      class Example {
          int i;
	  string s;
      };

    the following constructors are generated:

      public class Example : Ice.ObjectImpl {
	  public Example() { /* ... */ }
	  public Example(int i, string s) { /* ... */ }
	  // ...
      }

    This allows you to construct a structure, class, or exception and
    supply values for the data members in a single statement, instead
    of having to assign to the members of a default-constructed
    instance.

    For derived exceptions and classes, the constructor expects values
    for all data members, including those of base exceptions or
    classes, in base-to-derived order of declaration.

Changes since version 2.1.1
---------------------------

- Fixed a bug in proxyToString() for bidirectional proxies.

- Fixed a bug with dynamic thread pools, where new threads were
  destroyed immediately after dispatch if <threadpool>.Size=1 and
  <threadpool>.SizeMax > 1.

- Added the configuration property Ice.Compression.Level to provide
  more control over the bzip2 algorithm used to compress Ice protocol
  messages.

- Fixed a bug in the code generator: incorrect code was generated
  if an operation used an exception from an unrelated module in
  its exception specification.

- Fixed a bug in the randomization code for multiple endpoints: if
  a proxy had two endpoints, they were not shuffled.

Changes since version 2.1.0
---------------------------

- Modified the Ice marshaling engine so that references to Ice objects
  are released as soon as possible.

- Fixed a number of race conditions that could cause a crash during
  process shutdown on multi-CPU machines.

- Added sequences of fixed-length elements to throughput demo.

- Fixed a bug that could cause an assert if connections could not be
  established in thread-per-connection mode.

- Added two new properties for controlling Active Connection
  Management (ACM). In prior releases ACM was governed by the property
  Ice.ConnectionIdleTime, which affected client- and server-side
  behavior. The new properties, Ice.ACM.Client and Ice.ACM.Server,
  now allow independent timeouts to be specified for client- and
  server-side ACM. Ice.ConnectionIdleTime is now deprecated.

- Reverted a change introduced in 2.1.0 in which retries were not
  attempted for oneway and batch oneway requests. Ice now behaves
  as it did in prior releases: if the connection associated with a
  oneway or batch oneway proxy is closed, an invocation on the proxy
  will transparently reestablish the connection. Please see the Ice
  manual for more information on the reliability of oneway and batch
  oneway reliability.

- Added -E option to the various Slice compilers to print preprocessor
  output on stdout.

- Fixed a bug in the option parsing for Ice tools such as slice2cpp,
  slice2java, slice2cs, etc. The option parser used to incorrectly
  complain about repeated options when in fact no option was
  repeated. Also changed the parser to permit options to follow an
  argument, so

      slice2cpp -I. x.ice

  and

      slice2cpp x.ice -I.

  are now equivalent.

Changes since version 2.0.0
---------------------------

- Fixed bug in the code generators for C# and VB: for sequences
  of structs and sequences of Object*, incorrect code was generated
  if a ["cs:collection"] or ["vb:collection"] metadata directive
  was used.

- We do not retry oneway or batch oneway requests anymore, except if
  there are problems during connection establishment. If we retry a
  oneway or batch oneway, previous oneways from the same batch, or
  previous oneways that are buffered by the IP stack implementation,
  are silently thrown away. This can lead to a situation where the
  latest oneway succeeds due to retry, but former oneways are
  discarded.

- Fixed a deadlock that could occur if a server cannot send data
  during connection validation.

- Fixed bug where marshalling would fail for sequences of integral
  types on big endian platforms.

- Fixed bug where connection establishment could raise a 
  System.Net.Sockets.SocketException instead of an Ice.SocketException.

- Added setDefaultContext() and getDefaultContext() to the
  Ice.Communicator interface. This allows a default context to be
  established on a communicator-wide basis. See section 29.9.3 in the
  doc.

  Added ice_defaultContext to Ice.ObjectPrx. This creates a new
  proxy that uses the default context established on the communicator.

- Overloaded the checkedCast member function of the generated PrxHelper
  classes to allow a trailing argument of type Ice::Context. This makes
  it possible to do stateful things that require a context in a
  servant locator's activate() method.

- Fixed a bug in slice2cs: incorrect code was generated if an interface
  was derived from a base interface in a different module and the base
  interface contained an AMD operation.

Changes since version 1.5.1
---------------------------

- The proxy returned by the object adapter operations addFacet and
  addFacetWithUUID did not contain the facet. This required the
  application to make an extra call to ice_newFacet in order to
  obtain the correct proxy. This has been fixed.

- Added the object adapter property <name>.PublishedEndpoints, which
  specifies endpoints to advertise in proxies created by the adapter.

- Fixed a bug with AMD exception handling, where it was possible that
  certain exceptions propagate out of ice_response() or
  ice_exception(), and therefore such exceptions were not handled
  properly.

- Exceptions raised while marshaling data for batch requests resulted
  in a connection deadlock. This has been fixed.

- Fixed a bug in slice2cs: the generated code was incorrect for
  dictionaries and structures containing a sequence, if that sequence
  was mapped to an array.

- Fixed tracing of operation mode.

- The escape prefix for Slice identifiers that are used by .NET
  framework classes has been changed from "_cs_" to "_Ice_".  For
  example, Slice "Add" now maps to C# "_Ice_Add" instead of "_cs_Add".

  In addition, the prefix is now case-insensitive, so Slice "add" now
  maps to C# "_Ice_add" whereas, previously, it mapped to C# "add".
  (These changes were necessary to preserve binary compatibility of
  slice2cs and slice2vb generated code.)

- The documentation has always stated that same-named constructs
  cannot be directly nested inside each other. (For example, a module
  `M' cannot contain a constant named `M'. The slice2cs compiler did
  not enforce this correctly up to now for modules containing
  constructs with the same name as the enclosing module.  This has
  been fixed and now results in a diagnostic.

- The slice2cs compiler now disallows Slice definitions at global
  scope: only modules can be defined at global scope. Everything else
  (constants, classes, interfaces, etc.) must be defined inside a
  module.

- Fixed a bug in the slice2cs code generator:
  
  ["cs:collection"] sequence<Object> S1;
  ["cs:collection"] sequence<Object*> S2;

  Sequences of Object or Object* caused incorrect code to be generated
  if they were marked as "cs:collection".

- Fixed a bug in the slice2cs code generator: for nested sequences,
  incorrect code was generated if both the inner and the outer
  sequence were mapped as arrays.

- Fixed a number of bugs in slice2cs that cause incorrect code to be
  generated if C# keywords were used as Slice identifiers.

- Fixed the and slice2cs compiler for operations with multiple
  exceptions in an exception specification: if an exception was a base
  of one or more other exceptions in the same exception specification,
  the code generator sometimes emitted the catch blocks in the
  marshaling and dispatch code in the wrong order. (This applied only
  to interfaces with an ["amd"] metadata directive.)

- Several demos used Slice classes where interfaces were more
  appropriate. This has been fixed.

- Ice.Util.initializeWithProperties() now correctly parses the command
  line arguments.

- New properties Ice.StdErr and Ice.StdOut to redirect the standard
  error and output streams of a process.

- Added test and demo for using Ice for C# with Glacier.

- Changed the slice2cs code generator to avoid generating empty
  namespaces.

Changes since version 1.5.0
---------------------------

- Compression is now supported for non-Windows platforms as well
  as on Windows.

- Fixed a bug in the slice2cs code generator: classes with multiple
  sequence members caused incorrect code to be generated.

- Fixed a bug that sometimes prevented correct connection
  establishment under Windows.

Changes since Alpha 2
---------------------

- Added support for generating checksums of Slice definitions,
  enabling peers to verify that they share the same client-server
  contract. See the manual for more information.

- Added support for Mono.

- The DLL that contains the Ice for C# run time has been renamed from
  Icicle.dll to icecs.dll.

- Added support for protocol compression.

- Added extensive documentation for the language mapping to
  "Distributed Programming with Ice" (http://www.zeroc.com/Ice-Manual.pdf).

- Added support for AMI and AMD.

- Removed "cs:array" directive for sequences. Sequences are now mapped
  to arrays by default. If you want a sequence to map to a container
  derived from System.Collections.CollectionBase, you need to use
  the "cs:collection" metadata directive.

- Added "cs:class" metadata directive for Slice structures. Without
  this directive, Slice structures map to C# structures. With this
  directive, Slice structures map to C# classes.

- Added a key pair to the distribution so the assembly has a strong
  name and can be added to the global assembly cache. If you want to
  use your own key pair, you can replace the contents of
  src/Ice/IcecsKey.snk with your own key pair. See
  http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpguide/html/cpconcreatingkeypairforuseincreatingstrongly-namedassembly.asp
  for more detail.

- The generated code is more efficient and smaller than it was
  previously.


Changes since Alpha 1
---------------------

- Changed the generate.cs code to look for slice2cs in
  ${SolutionDir}/bin.

- Added "cs:array" metadata directive for sequences.  Sequences with
  this directive are mapped to arrays instead of being derived from
  Collections.CollectionBase.

- Improved marshaling speed.
