/// <summary>
/// Reads a value of the given type T from the stream which uses the underlying marshaler to unmarshal it.
/// </summary>
/// <typeparam name="T">The type of the value to be read.</typeparam>
/// <returns>The value read from the channel.</returns>
public virtual T Read <T>()
{
lock (readerLock)
{
StreamRegion region = new StreamRegion(this, 0);
object value = readerMarshaler.UnmarshalFrom(new MarshalingDescriptor(typeof(T)), region);
AdvanceReadBuffer(region.Offset);
return((T)value);
}
}
public static T[] ToArray <T>(IntPtr ptr, int size) where T : struct
{
if (ptr == IntPtr.Zero)
{
return(null);
}
if (size == 0)
{
return(new T[0]);
}
MarshalingDescriptor marshalDesc;
Marshaler marshaller = CreateNativeMarshaller(
typeof(T[]),
null,
size,
null,
false,
-1,
out marshalDesc);
int arraySize = marshaller.GetSize(marshalDesc, null);
IRegion region = marshaller.MakeRegion(ptr, arraySize);
return((T[])marshaller.UnmarshalFrom(marshalDesc, region));
}
public static T ToStruct <T>(
IntPtr ptr,
object switchValue,
object sizeValue,
object lengthValue,
bool force32Bit = false,
int align = -1) where T : struct
{
MarshalingDescriptor marshalDesc;
Marshaler marshaller = CreateNativeMarshaller(
typeof(T),
switchValue,
sizeValue,
lengthValue,
force32Bit,
align,
out marshalDesc);
int size = marshaller.GetSize(marshalDesc, null);
IRegion region = marshaller.MakeRegion(ptr, size);
return((T)marshaller.UnmarshalFrom(marshalDesc, region));
}
protected override IMessage Invoke(IMethodCallMessage mcall)
{
Marshaler marshaler = new Marshaler(site, NativeMarshalingConfiguration.Configuration);
foreach (Type type in proxiedType.Assembly.GetTypes())
{
marshaler.DefineCustomType(type.Name, type);
}
if (mcall.MethodBase == getHandleMethod)
return GetHandle(mcall);
if (mcall.MethodBase == setHandleMethod)
return SetHandle(mcall);
Initialize();
RpcStub stub;
if (!stubs.TryGetValue(mcall.MethodBase, out stub))
throw new InvalidOperationException(String.Format("cannot find stub for method '{0}'", mcall.MethodBase));
// marshal parameters
int n = stub.parameters.Length;
int actualsOffs = handleImplicit ? 1 : 0;
object[] actuals = new object[n + actualsOffs];
if (handleImplicit)
{
if (handle == null)
marshaler.TestAssumeFail(
"handle undefined for rpc interface '{0}' with implicit handle passing",
proxiedType);
IntPtr ptr = Marshal.StringToHGlobalUni(handle);
marshaler.MarkMemoryForDispose(ptr);
actuals[0] = ptr;
}
marshaler.EnterContext();
for (int i = 0; i < n; i++)
{
if (!stub.parameters[i].IsOut)
{
marshaler.DefineSymbol(mcall.GetArgName(i), mcall.Args[i]);
}
}
ParameterInfo[] parameterInfos = mcall.MethodBase.GetParameters();
for (int pass = 0; pass < 2; pass++)
{
for (int i = 0; i < n; i++)
{
if (pass == 0 && stub.parameters[i].HasDynamicExpression)
{
continue;
}
if (pass == 1
&& !stub.parameters[i].HasDynamicExpression)
{
continue;
}
stub.parameters[i].AllocateMemoryRegion(marshaler, mcall.Args[i]);
RpcParameter rp = stub.parameters[i];
if (rp.marshallingRegion != null)
rp.marshallingRegion.TryReset();
if (!rp.IsOut
&& mcall.Args[i] != null)
{
object value = mcall.Args[i];
// Validate the value of the parameter.
if (this.needAutoValidate)
CheckParameter(parameterInfos[i], value, mcall, marshaler.SymbolStore);
marshaler.MarshalInto(rp.context, rp.marshallingRegion, mcall.Args[i]);
}
else
{
marshaler.EnterRegion(rp.marshallingRegion);
marshaler.Clear(marshaler.GetSize(rp.context, null));
marshaler.ExitRegion();
}
if (!rp.IsByRef)
{
actuals[i + actualsOffs] = rp.Get();
}
else
{
if (mcall.Args[i] == null && !rp.IsOut)
{
actuals[i + actualsOffs] = IntPtr.Zero;
}
else
{
actuals[i + actualsOffs] = rp.marshallingRegion.NativeMemory;
}
}
marshaler.DefineSymbol(mcall.GetArgName(i), actuals[i + actualsOffs]);
}
}
// call
object result;
try
{
result = stub.stubMethod.Invoke(null, actuals);
}
catch (TargetInvocationException e)
{
throw e.InnerException;
}
// marshal output parameters
object[] resultArgs = new object[n];
marshaler.IsProbingUnmarshaling = true;
for (int pass = 0; pass < 2; pass++)
{
for (int i = 0; i < n; i++)
{
RpcParameter rp = stub.parameters[i];
if (rp.marshallingRegion != null)
rp.marshallingRegion.TryReset();
if (rp.IsByRef)
{
object res = resultArgs[i] =
marshaler.UnmarshalFrom(rp.context, rp.marshallingRegion);
if (marshaler.IsProbingUnmarshaling == false)
{
RpcAdapterValidate(res, rp.context.Attributes, marshaler.SymbolStore);
if (rp.IsOut && marshaler.GetNativeType(rp.context) == typeof(IntPtr))
{
foreach (IntPtr ptr in marshaler.ForeignMemory)
{
if (ptr != IntPtr.Zero && rpcFreeMethod != null)
{
rpcFreeMethod.Invoke(null, new object[] { ptr });
}
}
}
}
marshaler.ForeignMemory.Clear();
if (!rp.IsByRef)
{
marshaler.DefineSymbol(mcall.GetArgName(i), rp.Get());
}
else
{
marshaler.DefineSymbol(mcall.GetArgName(i),
rp.marshallingRegion.NativeMemory);
}
}
else
{
resultArgs[i] = mcall.Args[i];
}
}
marshaler.IsProbingUnmarshaling = false;
}
if (stub.returnParameter.nativeType != typeof(void))
{
stub.returnParameter.AllocateMemoryRegion(marshaler, result);
stub.returnParameter.marshallingRegion.TryReset();
stub.returnParameter.Set(result);
result = marshaler.UnmarshalFrom(
stub.returnParameter.context,
stub.returnParameter.marshallingRegion);
RpcAdapterValidate(result, null, null);
}
marshaler.ExitContext();
marshaler.FreeMemory();
marshaler.Dispose();
marshaler = null;
CheckOperation(mcall);
ReturnMessage mret = new ReturnMessage(result, resultArgs, resultArgs.Length, mcall.LogicalCallContext, mcall);
return mret;
}
