protobuf-net
Simple base class for supporting unexpected fields allowing
for loss-less round-tips/merge, even if the data is not understod.
The additional fields are (by default) stored in-memory in a buffer.
As an example of an alternative implementation, you might
choose to use the file system (temporary files) as the back-end, tracking
only the paths [such an object would ideally be IDisposable and use
a finalizer to ensure that the files are removed].
Indicates that the implementing type has support for protocol-buffer
extensions.
Can be implemented by deriving from .
Retrieves the extension object for the current
instance, optionally creating it if it does not already exist.
Should a new extension object be
created if it does not already exist?
The extension object if it exists (or was created), or null
if the extension object does not exist or is not available.
The createIfMissing argument is false during serialization,
and true during deserialization upon encountering unexpected fields.
Retrieves the extension object for the current
instance, optionally creating it if it does not already exist.
Should a new extension object be
created if it does not already exist?
The extension object if it exists (or was created), or null
if the extension object does not exist or is not available.
The createIfMissing argument is false during serialization,
and true during deserialization upon encountering unexpected fields.
Provides a simple, default implementation for extension support,
optionally creating it if it does not already exist. Designed to be called by
classes implementing .
Should a new extension object be
created if it does not already exist?
The extension field to check (and possibly update).
The extension object if it exists (or was created), or null
if the extension object does not exist or is not available.
The createIfMissing argument is false during serialization,
and true during deserialization upon encountering unexpected fields.
Appends the value as an additional (unexpected) data-field for the instance.
Note that for non-repeated sub-objects, this equates to a merge operation;
for repeated sub-objects this adds a new instance to the set; for simple
values the new value supercedes the old value.
Note that appending a value does not remove the old value from
the stream; avoid repeatedly appending values for the same field.
The type of the value to append.
The extensible object to append the value to.
The field identifier; the tag should not be defined as a known data-field for the instance.
The value to append.
Appends the value as an additional (unexpected) data-field for the instance.
Note that for non-repeated sub-objects, this equates to a merge operation;
for repeated sub-objects this adds a new instance to the set; for simple
values the new value supercedes the old value.
Note that appending a value does not remove the old value from
the stream; avoid repeatedly appending values for the same field.
The data-type of the field.
The data-format to use when encoding the value.
The extensible object to append the value to.
The field identifier; the tag should not be defined as a known data-field for the instance.
The value to append.
Queries an extensible object for an additional (unexpected) data-field for the instance.
The value returned is the composed value after merging any duplicated content; if the
value is "repeated" (a list), then use GetValues instead.
The data-type of the field.
The extensible object to obtain the value from.
The field identifier; the tag should not be defined as a known data-field for the instance.
The effective value of the field, or the default value if not found.
Queries an extensible object for an additional (unexpected) data-field for the instance.
The value returned is the composed value after merging any duplicated content; if the
value is "repeated" (a list), then use GetValues instead.
The data-type of the field.
The extensible object to obtain the value from.
The field identifier; the tag should not be defined as a known data-field for the instance.
The data-format to use when decoding the value.
The effective value of the field, or the default value if not found.
Queries an extensible object for an additional (unexpected) data-field for the instance.
The value returned (in "value") is the composed value after merging any duplicated content;
if the value is "repeated" (a list), then use GetValues instead.
The data-type of the field.
The effective value of the field, or the default value if not found.
The extensible object to obtain the value from.
The field identifier; the tag should not be defined as a known data-field for the instance.
True if data for the field was present, false otherwise.
Queries an extensible object for an additional (unexpected) data-field for the instance.
The value returned (in "value") is the composed value after merging any duplicated content;
if the value is "repeated" (a list), then use GetValues instead.
The data-type of the field.
The effective value of the field, or the default value if not found.
The extensible object to obtain the value from.
The field identifier; the tag should not be defined as a known data-field for the instance.
The data-format to use when decoding the value.
True if data for the field was present, false otherwise.
Queries an extensible object for an additional (unexpected) data-field for the instance.
The value returned (in "value") is the composed value after merging any duplicated content;
if the value is "repeated" (a list), then use GetValues instead.
The data-type of the field.
The effective value of the field, or the default value if not found.
The extensible object to obtain the value from.
The field identifier; the tag should not be defined as a known data-field for the instance.
The data-format to use when decoding the value.
Allow tags that are present as part of the definition; for example, to query unknown enum values.
True if data for the field was present, false otherwise.
Queries an extensible object for an additional (unexpected) data-field for the instance.
Each occurrence of the field is yielded separately, making this usage suitable for "repeated"
(list) fields.
The extended data is processed lazily as the enumerator is iterated.
The data-type of the field.
The extensible object to obtain the value from.
The field identifier; the tag should not be defined as a known data-field for the instance.
An enumerator that yields each occurrence of the field.
Queries an extensible object for an additional (unexpected) data-field for the instance.
Each occurrence of the field is yielded separately, making this usage suitable for "repeated"
(list) fields.
The extended data is processed lazily as the enumerator is iterated.
The data-type of the field.
The extensible object to obtain the value from.
The field identifier; the tag should not be defined as a known data-field for the instance.
The data-format to use when decoding the value.
An enumerator that yields each occurrence of the field.
Provides protocol-buffer serialization capability for concrete, attributed types.
Protocol-buffer serialization is a compact binary format, designed to take
advantage of sparse data and knowledge of specific data types; it is also
extensible, allowing a type to be deserialized / merged even if some data is
not recognised.
The implicit tag used when serializing lists and other enumerable data.
Supports various different property metadata patterns:
[ProtoMember] is the most specific, allowing the data-format to be set.
[DataMember], [XmlElement] are supported for compatibility.
In any event, there must be a unique positive Tag/Order.
Creates a new instance from a protocol-buffer stream
The type to be created.
The binary stream to apply to the new instance (cannot be null).
A new, initialized instance.
Creates a new instance from a protocol-buffer stream that has a length-prefix
on data (to assist with network IO).
The type to be created.
The binary stream to apply to the new instance (cannot be null).
A new, initialized instance.
Reads a sequence of consecutive length-prefixed items from a stream, using
either base-128 or fixed-length prefixes. Base-128 prefixes with a tag
are directly comparable to serializing multiple items in succession
(use the tag to emulate the implicit behavior
when serializing a list/array). When a tag is
specified, any records with different tags are silently omitted. The
tag is ignored. The tag is ignores for fixed-length prefixes.
The type of object to deserialize.
The binary stream containing the serialized records.
The prefix style used in the data.
The tag of records to return (if non-positive, then no tag is
expected and all records are returned).
The sequence of deserialized objects.
Creates a new instance from a protocol-buffer stream that has a length-prefix
on data (to assist with network IO).
The type to be created.
The binary stream to apply to the new instance (cannot be null).
How to encode the length prefix.
A new, initialized instance.
Creates a new instance from a protocol-buffer stream that has a length-prefix
on data (to assist with network IO).
The type to be created.
The binary stream to apply to the new instance (cannot be null).
How to encode the length prefix.
The expected tag of the item (only used with base-128 prefix style).
A new, initialized instance.
Indicates the number of bytes expected for the next message.
The stream containing the data to investigate for a length.
The algorithm used to encode the length.
The length of the message, if it could be identified.
True if a length could be obtained, false otherwise.
Indicates the number of bytes expected for the next message.
The buffer containing the data to investigate for a length.
The offset of the first byte to read from the buffer.
The number of bytes to read from the buffer.
The algorithm used to encode the length.
The length of the message, if it could be identified.
True if a length could be obtained, false otherwise.
Applies a protocol-buffer stream to an existing instance.
The type being merged.
The existing instance to be modified (can be null).
The binary stream to apply to the instance (cannot be null).
The updated instance; this may be different to the instance argument if
either the original instance was null, or the stream defines a known sub-type of the
original instance.
Applies a protocol-buffer stream to an existing instance, using length-prefixed
data - useful with network IO.
The type being merged.
The existing instance to be modified (can be null).
The binary stream to apply to the instance (cannot be null).
The updated instance; this may be different to the instance argument if
either the original instance was null, or the stream defines a known sub-type of the
original instance.
Applies a protocol-buffer stream to an existing instance, using length-prefixed
data - useful with network IO.
The type being merged.
The existing instance to be modified (can be null).
The binary stream to apply to the instance (cannot be null).
How to encode the length prefix.
The updated instance; this may be different to the instance argument if
either the original instance was null, or the stream defines a known sub-type of the
original instance.
Writes a protocol-buffer representation of the given instance to the supplied stream.
The type being serialized.
The existing instance to be serialized (cannot be null).
The destination stream to write to.
Writes a protocol-buffer representation of the given instance to the supplied stream,
with a length-prefix. This is useful for socket programming,
as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back
from an ongoing stream.
The type being serialized.
The existing instance to be serialized (cannot be null).
The destination stream to write to.
Writes a protocol-buffer representation of the given instance to the supplied stream,
with a length-prefix. This is useful for socket programming,
as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back
from an ongoing stream.
The type being serialized.
The existing instance to be serialized (cannot be null).
How to encode the length prefix.
The destination stream to write to.
Writes a protocol-buffer representation of the given instance to the supplied stream,
with a length-prefix. This is useful for socket programming,
as DeserializeWithLengthPrefix/MergeWithLengthPrefix can be used to read the single object back
from an ongoing stream.
The type being serialized.
The existing instance to be serialized (cannot be null).
How to encode the length prefix.
The destination stream to write to.
The tag used as a prefix to each record (only used with base-128 style prefixes).
Creates a new IFormatter that uses protocol-buffer [de]serialization.
The type of object to be [de]deserialized by the formatter.
A new IFormatter to be used during [de]serialization.
Writes a protocol-buffer representation of the given instance to the supplied SerializationInfo.
The type being serialized.
The existing instance to be serialized (cannot be null).
The destination SerializationInfo to write to.
Applies a protocol-buffer from a SerializationInfo to an existing instance.
The type being merged.
The existing instance to be modified (cannot be null).
The SerializationInfo containing the data to apply to the instance (cannot be null).
Writes a protocol-buffer representation of the given instance to the supplied XmlWriter.
The type being serialized.
The existing instance to be serialized (cannot be null).
The destination XmlWriter to write to.
Applies a protocol-buffer from an XmlReader to an existing instance.
The type being merged.
The existing instance to be modified (cannot be null).
The XmlReader containing the data to apply to the instance (cannot be null).
Create a deep clone of the supplied instance; any sub-items are also cloned.
The type being cloned.
The existing instance to be cloned.
A new copy, cloned from the supplied instance.
Serializes a given instance and deserializes it as a different type;
this can be used to translate between wire-compatible objects (where
two .NET types represent the same data), or to promote/demote a type
through an inheritance hierarchy.
No assumption of compatibility is made between the types.
The type of the object being copied.
The type of the new object to be created.
The existing instance to use as a template.
A new instane of type TNewType, with the data from TOldType.
As per the public ChangeType, but allows for workspace-sharing to reduce buffer overhead.
Suggest a .proto definition for the given type
The type to generate a .proto definition for
The .proto definition as a string
Ensures that the serialization algorithm has been prepared for
the given type; this can be useful in highly threaded code to
ensure that all types are ready ahead of time, avoiding deadlock
scenarios.
The object type to prepare.
Global switches that change the behavior of protobuf-net
Global default for that
enables/disables automatic tag generation based on the existing name / order
of the defined members. See
for usage and important warning / explanation.
You must set the global default before attempting to serialize/deserialize any
impacted type.
Provides non-generic, reflection-based access to Serializer functionality
Writes a protocol-buffer representation of the given instance to the supplied stream.
The existing instance to be serialized (cannot be null).
How to encode the length prefix.
The destination stream to write to.
The tag used as a prefix to each record (only used with base-128 style prefixes).
Can the given type be meaningfully with protobuf-net?
Writes a protocol-buffer representation of the given instance to the supplied stream.
The existing instance to be serialized (cannot be null).
The destination stream to write to.
Deserialize object of unknown types from in input stream.
The input stream.
The prefix style used to encode the lengths.
The caller must provide a mechanism to resolve a Type from
the tags encountered in the stream. If the delegate returns null, then the instance
is skipped - otherwise, the object is deserialized according to type.
The deserialized instance, or null if the stream terminated.
True if an object was idenfified; false if the stream terminated. Note
that unexpected types are skipped.
Creates a new instance from a protocol-buffer stream
The type to be created.
The binary stream to apply to the new instance (cannot be null).
A new, initialized instance.
Create a deep clone of the supplied instance; any sub-items are also cloned.
The existing instance to be cloned.
A new copy, cloned from the supplied instance.
Indicates that an EOF is not anticipated, and so will throw an exception.
Indicates that an EOF is acceptable at the current time and will
not throw an exception.
Indicates that we have previously obtained a field value from
the stream that should be consumed next.
Indicates that we have found the end of the stream; this is **only**
used to commicate to "Try", and should not persist.
Allows for recursion detection by capturing
the call tree; this only takes effect after
an initial threshold call-depth is reached.
If the object is already in the call-tree,
an exception is thrown.
The item being processed (start).
Only used during debugging for the text nest-level
Only used during debugging for the text nest-level
Removes an object from the call-tree.
The object is not checked for validity (peformance);
ensure that objects are pushed/popped correctly.
The item being processed (end).
Slow (unbuffered) read from a stream; used to avoid issues
with buffers when performing network IO.
Slow (unbuffered) read from a stream; used to avoid issues
with buffers when performing network IO.
Slow (unbuffered) read from a stream; used to avoid issues
with buffers when performing network IO.
Jump a block of data using a base-128 length prefix.
The input stream.
Slow (unbuffered) read from a stream; used to avoid issues
with buffers when performing network IO.
True if there is data in the stream and a value can be obtained;
False if there is no data in the stream; note that an exception is still
thrown if the data is invalid.
Fills the IO buffer if there is not enough data buffered to complete the current operation.
The maximum number of bytes required by the current operation.
Should an exception be thrown if the data is not available?
Fills the IO buffer, moving any un-consumed data to the beginning of the cache.
Flushes the IO buffer if there is not enough space to complete the current operation.
The maximum number of bytes required by the current operation.
Flushes the IO buffer, writing any cached data to the underlying stream and resetting the cache.
Base-128 variant-length encoding
Fixed-length 8-byte encoding
Length-variant-prefixed encoding
Indicates the start of a group
Indicates the end of a group
Fixed-length 4-byte encoding
Sub-format to use when serializing/deserializing data
Uses the default encoding for the data-type.
When applied to signed integer-based data (including Decimal), this
indicates that zigzag variant encoding will be used. This means that values
with small magnitude (regardless of sign) take a small amount
of space to encode.
When applied to signed integer-based data (including Decimal), this
indicates that two's-complement variant encoding will be used.
This means that any -ve number will take 10 bytes (even for 32-bit),
so should only be used for compatibility.
When applied to signed integer-based data (including Decimal), this
indicates that a fixed amount of space will be used.
When applied to a sub-message, indicates that the value should be treated
as group-delimited.
Indicates the known-types to support for an individual
message. This serializes each level in the hierarchy as
a nested message to retain wire-compatibility with
other protocol-buffer implementations.
Creates a new instance of the ProtoIncludeAttribute.
The unique index (within the type) that will identify this data.
The additional type to serialize/deserialize.
Creates a new instance of the ProtoIncludeAttribute.
The unique index (within the type) that will identify this data.
The additional type to serialize/deserialize.
Gets the unique index (within the type) that will identify this data.
Gets the additional type to serialize/deserialize.
Gets the additional type to serialize/deserialize.
Specifies whether the inherited sype's sub-message should be
written with a length-prefix (default), or with group markers.
Indicates that a type is defined for protocol-buffer serialization.
Gets or sets the defined name of the type.
Gets or sets the fist offset to use with implicit field tags;
only uesd if ImplicitFields is set.
Gets or sets the mechanism used to automatically infer field tags
for members. This option should be used in advanced scenarios only.
Please review the important notes against the ImplicitFields enumeration.
Enables/disables automatic tag generation based on the existing name / order
of the defined members. This option is not used for members marked
with ProtoMemberAttribute, as intended to provide compatibility with
WCF serialization. WARNING: when adding new fields you must take
care to increase the Order for new elements, otherwise data corruption
may occur.
If not specified, the default is assumed from .
Specifies an offset to apply to [DataMember(Order=...)] markers;
this is useful when working with mex-generated classes that have
a different origin (usually 1 vs 0) than the original data-contract.
This value is added to the Order of each member.
Used to define protocol-buffer specific behavior for
enumerated values.
Indicates whether this instance has a customised value mapping
true if a specific value is set
Gets or sets the specific value to use for this enum during serialization.
Gets or sets the defined name of the enum, as used in .proto
(this name is not used during serialization).
Declares a member to be used in protocol-buffer serialization, using
the given Tag. A DataFormat may be used to optimise the serialization
format (for instance, using zigzag encoding for negative numbers, or
fixed-length encoding for large values.
Creates a new ProtoMemberAttribute instance.
Specifies the unique tag used to identify this member within the type.
Gets or sets the original name defined in the .proto; not used
during serialization.
Gets or sets the data-format to be used when encoding this value.
Gets the unique tag used to identify this member within the type.
Gets or sets a value indicating whether this member is mandatory.
Gets or sets a value indicating whether this member is packed (lists/arrays).
Additional (optional) settings that control serialization of members
Default; no additional options
Indicates that repeated elements should use packed (length-prefixed) encoding
Indicates that the given item is required
Declares a member to be used in protocol-buffer serialization, using
the given Tag and MemberName. This allows ProtoMemberAttribute usage
even for partial classes where the individual members are not
under direct control.
A DataFormat may be used to optimise the serialization
format (for instance, using zigzag encoding for negative numbers, or
fixed-length encoding for large values.
Creates a new ProtoMemberAttribute instance.
Specifies the unique tag used to identify this member within the type.
Specifies the member to be serialized.
The name of the member to be serialized.
Describes a Stream that wraps an underlying stream but
which limits the length. This is used for processing
length-prefied messages (string wire-type) so that no
complex code is required to manage the end of each
object.
This class acts as an internal wrapper allowing us to do a dynamic
methodinfo invoke; an't put into Serializer as don't want on public
API; can't put into Serializer<T> since we need to invoke
accross classes, which isn't allowed in Silverlight)
All this does is call GetExtendedValuesTyped with the correct type for "instance";
this ensures that we don't get issues with subclasses declaring conflicting types -
the caller must respect the fields defined for the type they pass in.
Reads the given value(s) from the instance's stream; the serializer
is inferred from TValue and format. For singletons, each occurrence
is merged [only applies for sub-objects], and the composed
value if yielded once; otherwise ("repeated") each occurrence
is yielded separately.
Needs to be public to be callable thru reflection in Silverlight
All this does is call AppendExtendValueTyped with the correct type for "instance";
this ensures that we don't get issues with subclasses declaring conflicting types -
the caller must respect the fields defined for the type they pass in.
Stores the given value into the instance's stream; the serializer
is inferred from TValue and format.
Needs to be public to be callable thru reflection in Silverlight
Indicates an error during serialization/deserialization of a proto stream.
Creates a new ProtoException instance.
Creates a new ProtoException instance.
Creates a new ProtoException instance.
Creates a new ProtoException instance.
The (non-extensible) UnknownType is used when deserializing
unexpected groups.
Simplified calling convention for asynchronous Begin/End operations.
The type of data returned by the async operation.
The start (Begin*) of the async operation.
The end (End*) of the async operation.
The operation to perform once the operation has completed and a value received.
Callback to invoke when an excetption is thrown during the async operation.
Defines the start of a Begin/End async operation pair.
The type of value returned by the async operation.
The operation to be performed.
User-state to be passed to the operation.
A token to the async operation.
Defines the completion callback of a Begin/End async operation pair.
The type of value returned by the async operation.
The async operation token.
The final value of the async operation.
Provides a simple buffer-based implementation of an extension object.
Provides addition capability for supporting unexpected fields during
protocol-buffer serialization/deserialization. This allows for loss-less
round-trip/merge, even when the data is not fully understood.
Requests a stream into which any unexpected fields can be persisted.
A new stream suitable for storing data.
Indicates that all unexpected fields have now been stored. The
implementing class is responsible for closing the stream. If
"commit" is not true the data may be discarded.
The stream originally obtained by BeginAppend.
True if the append operation completed successfully.
Requests a stream of the unexpected fields previously stored.
A prepared stream of the unexpected fields.
Indicates that all unexpected fields have now been read. The
implementing class is responsible for closing the stream.
The stream originally obtained by BeginQuery.
Requests the length of the raw binary stream; this is used
when serializing sub-entities to indicate the expected size.
The length of the binary stream representing unexpected data.
Specifies a method on the root-contract in an hierarchy to be invoked before serialization.
Specifies a method on the root-contract in an hierarchy to be invoked after serialization.
Specifies a method on the root-contract in an hierarchy to be invoked before deserialization.
Specifies a method on the root-contract in an hierarchy to be invoked after deserialization.
Represents the function to obtain the return value from an asynchronouse operation;
comparable to Func<object>.
Returns the required value from an instance; comparable to Func<TEntity,TValue>
Assigns the required value to an instance; comparable to Action<TEntity,TValue>.
Specifies the method used to infer field tags for members of the type
under consideration. Tags are deduced using the invariant alphabetic
sequence of the members' names; this makes implicit field tags very brittle,
and susceptible to changes such as field names (normally an isolated
change).
No members are serialized implicitly; all members require a suitable
attribute such as [ProtoMember]. This is the recmomended mode for
most scenarios.
Public properties and fields are eligible for implicit serialization;
this treats the public API as a contract.
Public and non-public fields are eligible for implicit serialization;
this acts as a state/implementation serializer.
Abstract object factory, used to negate the need for a ": new()" generic constraint
on Serializer-of-T.
The type of object to be created.
Specifies the type of prefix that should be applied to messages.
No length prefix is applied to the data; the data is terminated only be the end of the stream.
A base-128 length prefix is applied to the data (efficient for short messages).
A fixed-length (little-endian) length prefix is applied to the data (useful for compatibility).
Property implemenation that handles enum values.
All enum wire-values must be in the Int32 range.
Utility class for creating/initializing protobuf-net property
wrappers.
Returns a Getter<T,T> delegate that simply returns
the original value. This allows code re-use between
different implementations.
Originally an anonymous method was used, but
this proved problematic with the Mono 2.0 compiler.
Create a simple Property that can be used standalone
to encode/decode values for the given type.
Create a Property based around a class
member (PropertyInfo/FieldInfo).
Responsible for deciding how to encode/decode a given data-type; maybe
not the most elegant solution, but it is simple and quick.
Stores, per T, a pass-thru Getter<T,T> delegate.
Serializes an entity using string (length-prefixed) syntax.
The high number of type arguments is requird to support ancestral serialization;
there are 2 use-cases:
direct: for example, a property (base is the highest contract ancestor; prop = actual = the property-type)
descendent: used internally to cascade inheritance; prop = base = the parent type, actual = the child type
The type declaring the member
The defined member-type for accessing data
The base-type to use when verifying / instantiating sub-type instances
The type to use for serialization purposes
Serializes an entity using group (delimited) syntax.
The high number of type arguments is requird to support ancestral serialization;
there are 2 use-cases:
direct: for example, a property (base is the highest contract ancestor; prop = actual = the property-type)
descendent: used internally to cascade inheritance; prop = base = the parent type, actual = the child type
The type declaring the member
The defined member-type for accessing data
The base-type to use when verifying / instantiating sub-type instances
The type to use for serialization purposes
Indicates that a member should be excluded from serialization; this
is only normally used when using implict fields.
Indicates that a member should be excluded from serialization; this
is only normally used when using implict fields. This allows
ProtoIgnoreAttribute usage
even for partial classes where the individual members are not
under direct control.
Creates a new ProtoPartialIgnoreAttribute instance.
Specifies the member to be ignored.
The name of the member to be ignored.
Represents an exception raised through an event.
Creates a new instance of ExceptionEventArgs for the gievn exception.
The exception represented by the event.
Performs RPC using basic http POSTs to a web-server.
Provides the underlying transport for a family of RPC operations.
Begins an async operation over the transport.
The operation to perform (includes the facility
to provide a response for the operation).
Create a new HttpBasicTransport instance.
The endpoint for the service. By default, the servic
is assumed to be RESTful, and the action is appended as a route; the
route can be customized by including the "{action}" token in the uri.
Releases any resources associated with the transport.
Releases any resources associated with the transport.
Raises an exception if the instance has been disposed.
Utility operations common to RPC implementations.
Indicates whether the given parameter forms part of a request - i.e.
is "in" or "ref".
The parameter to test.
True if the given parameter is part of a request.
Indicates whether the given parameter forms part of a response - i.e.
is "out" or "ref".
The parameter to test.
True if the given parameter is part of a response.
Returns the name associated with a service contract.
The service-contract type.
The name of the service.
Standalone http server compatible with .
Provides common functionality required by RPC servers.
Adds a per-call service to the server. An instance of the type will
be created (and disposed if appropriate) per request.
The type of service-contract to provide.
The concrete type that will implement the service.
Adds a singleton service to the server. All requests will be
serviced by the supplied instance. This instance will be
disposed (if appropriate) with the server.
The type of service to provide.
Releases and nulls a given field/variable.
Performs any pre-response operations required.
Performs server-side processing of an action, including deserialization
of arguments, method-invokation, and serialization of the return value and
any `out`/`ref` arguments.
Represents a service endpoint provided by the server.
Obtains the instance representing the service endpoint for a call.
Releases the instance representing the service endpoint for a call.
Releases any resources associated with the endpoint.
Initialises a new service endpoint for the given service type.
Obtains the method that represents a given action.
The name of the action.
The method that should be invoked.
The name of the service endpoint.
Create a new HttpServer instance for the given service-type.
The base uri on which to listen for messages.
The interface that represents the service contract.
The concrete type that implements the service contract.
Create a new HttpServer instance for the given service-type.
The base uri on which to listen for messages.
Begin listening for messages on the server.
Performs any pre-response operations required.
Stop listening for messages on the server, and release
any associated resources.
Provides transport-independent wrapper logic for
managing RPC calls to the server.
The service contract that the client represents.
Releases any resources associated with the client.
Create a new client object.
The transport implementation to use.
Begins an RPC invokation asynchrononously.
The name of the method (on the service interface) to invoke.
The request payload.
The operation to perform when a response is received.
Performs an RPC invokation synchrononously.
The name of the method (on the service interface) to invoke.
The request payload.
The response payload.
Performs an RPC invokation synchrononously.
The method (on the service interface) to invoke.
The request payload.
The response payload.
Begins an RPC invokation asynchrononously.
The method (on the service interface) to invoke.
The request payload.
The operation to perform when a response is received.
Identify the action to use for a given method.
The method requested.
The action to use.
Identify the service to use for a given method.
The service requested.
The service to use.
Signals that an error occured processing RPC calls.
The error details.
Gets or sets the timeout (in milliseconds) for synchronous RPC operations.
Gets the transport mechanism associated with the client.
Raised when an error occurs processing RPC calls.
Represents an in-progress request (and response mechanism)
for a basic RPC stack.
Called by transports; signals that the operation failed.
The details of the failure.
Called by transports; signals that the operation succeeded.
The server's response the the request.
Create a new service request.
The contract-based name of the operation to perform.
The contract-based name of the service to use.
Provides reflection access to the contract member representing the operation.
The argument values for the method.
Caller-defined state for this operation.
The operation to perform when this request has completed.
Caller-defined state for this operation.
The object graph representing the query request object.
The object graph representing the server's response.
Descripbes any exception raised by the transport.
The contract-based name of the operation to perform.
The contract-based name of the service to ues.
Provides reflection access to the contract member representing the operation.