public void Marshaler_creates_factory_and_session()
{
//configure NHibernate
var config = new Configuration();
//initialize context
var session = new Marshaler(config).CurrentSession;
Assert.IsNotNull(session);
session.Dispose();
}
public void Marshaler_creates_factory_and_session()
{
//configure NHibernate
var config = new Configuration();
//initialize context
var session = new Marshaler(config).CurrentSession;
Assert.IsNotNull(session);
session.Dispose();
}
/// <summary>
/// Releases resources.
/// </summary>
/// <remarks>
/// Dispose(bool disposing) executes in two distinct scenarios.
/// If the parameter 'disposing' equals true, the method is called directly
/// or indirectly by a user's code. Managed and unmanaged resources
/// can be disposed.
/// If the parameter 'disposing' equals false, the method is called by the
/// runtime from the inside of the finalizer and you should not refer to
/// other objects. Therefore, only unmanaged resources can be disposed.
/// </remarks>
/// <param name="disposing">Indicates if Dispose is called by user.</param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (marshaler != null)
{
marshaler.Dispose();
marshaler = null;
}
}
}
public void Marshaler_returns_same_session_in_thread_static_context()
{
//configure NHibernate
var config = new Configuration();
//initialize context
var session1 = new Marshaler(config).CurrentSession;
Assert.IsNotNull(session1);
var session2 = new Marshaler(config).CurrentSession;
Assert.AreSame(session1, session2);
session1.Dispose();
session2.Dispose();
}
public void Marshaler_returns_new_stateless_sessions()
{
//configure NHibernate
var config = new Configuration();
//initialize context
var session1 = new Marshaler(config).GetStatelessSession();
Assert.IsNotNull(session1);
var session2 = new Marshaler(config).GetStatelessSession();
Assert.IsNotNull(session2);
Assert.AreNotSame(session1, session2);
session1.Dispose();
session2.Dispose();
}
public void Marshaler_can_access_stateful_session_before_stateless_session()
{
//configure NHibernate
var config = new Configuration();
//initialize context
var session1 = new Marshaler(config).CurrentSession;
Assert.IsNotNull(session1);
var session2 = new Marshaler(config).GetStatelessSession();
Assert.IsNotNull(session2);
Assert.AreNotSame(session1, session2);
session1.Dispose();
session2.Dispose();
}
public void Marshaler_returns_same_session_in_thread_static_context()
{
//configure NHibernate
var config = new Configuration();
//initialize context
var session1 = new Marshaler(config).CurrentSession;
Assert.IsNotNull(session1);
var session2 = new Marshaler(config).CurrentSession;
Assert.AreSame(session1, session2);
session1.Dispose();
session2.Dispose();
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
// Release managed resources.
if (marshaller != null)
{
marshaller.FreeMemory();
marshaller.Dispose();
marshaller = null;
}
}
base.Dispose(disposing);
}
public void Marshaler_returns_new_stateless_sessions()
{
//configure NHibernate
var config = new Configuration();
//initialize context
var session1 = new Marshaler(config).GetStatelessSession();
Assert.IsNotNull(session1);
var session2 = new Marshaler(config).GetStatelessSession();
Assert.IsNotNull(session2);
Assert.AreNotSame(session1, session2);
session1.Dispose();
session2.Dispose();
}
public void Marshaler_can_access_stateful_session_before_stateless_session()
{
//configure NHibernate
var config = new Configuration();
//initialize context
var session1 = new Marshaler(config).CurrentSession;
Assert.IsNotNull(session1);
var session2 = new Marshaler(config).GetStatelessSession();
Assert.IsNotNull(session2);
Assert.AreNotSame(session1, session2);
session1.Dispose();
session2.Dispose();
}
/// <summary>
/// Releases resources.
/// </summary>
/// <remarks>
/// Dispose(bool disposing) executes in two distinct scenarios.
/// If the parameter 'disposing' equals true, the method is called directly
/// or indirectly by a user's code. Managed and unmanaged resources
/// can be disposed.
/// If the parameter 'disposing' equals false, the method is called by the
/// runtime from the inside of the finalizer and you should not refer to
/// other objects. Therefore, only unmanaged resources can be disposed.
/// </remarks>
/// <param name="disposing">Indicates if Dispose is called by the user.</param>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (readerMarshaler != null)
{
readerMarshaler.Dispose();
readerMarshaler = null;
}
if (writerMarshaler != null)
{
writerMarshaler.Dispose();
writerMarshaler = null;
}
}
}
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;
}
public static void DisposeMarshaler(Marshaler m)
{
m.Dispose();
}
