Changes since version 3.2.0 --------------------------- - Added demo book/lifecycle. - Fixed object adapter activation deadlock. The deadlock could occur if another thread invokes concurrently on the locator while the adapter is registering its endpoints with the locator registry. - 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 : Indicates the protocol type (TCP = 1, SSL = 2, UDP = 3). -v : 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 plugin configured sends a proxy with an SSL endpoint to a server without the SSL plugin. 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 marshaling/unmarshaling methods for interfaces and allow them to be transferred 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 plugin property parsing code: if the file name of a plugin included a drive letter, the plugin 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 plugin or an IceBox service could result in a System.NullReferenceException if no constructors are available to create the plugin 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 plugin 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 .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, .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 _Disp but is now called 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 .Size=1 and .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 .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 S1; ["cs:collection"] sequence 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.