public new static void Marshal(ManagedExceptionNativeInfo value, Stream stream)
{
NativeUnitMarshaler <ManagedExceptionNativeInfo> .Marshal(value, stream);
UInt64Marshaler.Marshal(value.ClassId, stream);
StringMarshaler.Marshal(value.Message, stream);
MarshalingManager.Marshal(value.Stack, stream);
}
public new static ManagedExceptionNativeInfo Demarshal(Stream stream)
{
ManagedExceptionNativeInfo unit = NativeUnitMarshaler <ManagedExceptionNativeInfo> .Demarshal(stream);
unit.ClassId = UInt64Marshaler.Demarshal(stream);
unit.Message = StringMarshaler.Demarshal(stream);
unit.Stack = MarshalingManager.Demarshal <ulong[]>(stream);
return(unit);
}
static ProfilingTypeAdapter()
{
MarshalingManager.RegisterMarshaler(new Marshaling.AppDomainInfoMarshaler());
MarshalingManager.RegisterMarshaler(new Marshaling.AssemblyInfoMarshaler());
MarshalingManager.RegisterMarshaler(new Marshaling.ModuleInfoMarshaler());
MarshalingManager.RegisterMarshaler(new Marshaling.ClassInfoMarshaler());
MarshalingManager.RegisterMarshaler(new Marshaling.FunctionInfoMarshaler());
MarshalingManager.RegisterMarshaler(new Marshaling.ThreadInfoMarshaler());
}
public byte[] Serialize()
{
if (IsSerialized)
{
return(_data);
}
using (MemoryStream stream = new MemoryStream())
{
MarshalingManager.Marshal(_value, stream);
return(stream.ToArray());
}
}
public T GetValue <T>()
{
if (IsSerialized)
{
using (MemoryStream stream = new MemoryStream(_data))
{
_value = MarshalingManager.Demarshal <T>(stream);
}
MarkDeserialized();
}
return((T)_value);
}
public object ReadResult(Type returnType)
{
object result;
byte[] data = ByteArrayMarshaler.Demarshal(InputStream);
using (MemoryStream stream = new MemoryStream(data))
{
ITypeMarshaler marshaler = MarshalingManager.GetMarshaler(returnType);
result = marshaler.DemarshalObject(stream);
}
return(result);
}
public void WriteArguments(object[] arguments)
{
byte[] data;
using (MemoryStream stream = new MemoryStream())
{
foreach (object argument in arguments)
{
MarshalingManager.Marshal(argument, stream);
}
data = stream.ToArray();
}
ByteArrayMarshaler.Marshal(data, OutputStream);
}
public void WriteResult(object result)
{
if (result == null)
{
return;
}
byte[] data;
using (MemoryStream stream = new MemoryStream())
{
MarshalingManager.Marshal(result, stream);
data = stream.ToArray();
}
ByteArrayMarshaler.Marshal(data, OutputStream);
}
public object[] ReadArguments(Type[] signature)
{
object[] arguments = new object[signature.Length];
byte[] data = ByteArrayMarshaler.Demarshal(InputStream);
using (MemoryStream stream = new MemoryStream(data))
{
for (int i = 0; i < arguments.Length; i++)
{
Type type = signature[i];
ITypeMarshaler marshaler = MarshalingManager.GetMarshaler(type);
arguments[i] = marshaler.DemarshalObject(stream);
}
}
return(arguments);
}
public bool HandlePackage(NativeArray array)
{
using (Stream stream = array.OpenRead())
{
while (stream.Position < stream.Length)
{
UnitType unitType = (UnitType)Int32Marshaler.Demarshal(stream);
switch (unitType)
{
case UnitType.AppDomain:
AppDomainNativeInfo[] appDomains = MarshalingManager.Demarshal <AppDomainNativeInfo[]>(stream);
_appDomains.Update(appDomains);
break;
case UnitType.Assembly:
AssemblyNativeInfo[] assemblies = MarshalingManager.Demarshal <AssemblyNativeInfo[]>(stream);
_assemblies.Update(assemblies);
break;
case UnitType.Module:
ModuleNativeInfo[] modules = MarshalingManager.Demarshal <ModuleNativeInfo[]>(stream);
_modules.Update(modules);
break;
case UnitType.Class:
ClassNativeInfo[] classes = MarshalingManager.Demarshal <ClassNativeInfo[]>(stream);
_classes.Update(classes);
break;
case UnitType.Function:
FunctionNativeInfo[] functions = MarshalingManager.Demarshal <FunctionNativeInfo[]>(stream);
_functions.Update(functions);
break;
case UnitType.Thread:
ThreadNativeInfo[] threads = MarshalingManager.Demarshal <ThreadNativeInfo[]>(stream);
_threads.Update(threads);
break;
default:
throw new TempException("Unknown UnitType");
}
}
}
return(true);
}
public bool HandlePackage(NativeArray array)
{
using (Stream stream = array.OpenRead())
{
while (stream.Position < stream.Length)
{
UnitType unitType = (UnitType)Int32Marshaler.Demarshal(stream);
switch (unitType)
{
case UnitType.ManagedException:
ManagedExceptionNativeInfo[] exceptions = MarshalingManager.Demarshal <ManagedExceptionNativeInfo[]>(stream);
_exceptions.Update(exceptions);
break;
default:
throw new TempException("Unknown UnitType");
}
}
}
return(true);
}
static ProfilingTypeAdapter()
{
MarshalingManager.RegisterMarshaler(new Marshaling.ManagedExceptionInfoMarshaler());
}
static ProfilingTypeAdapter()
{
MarshalingManager.RegisterMarshaler(new Marshaling.MsSqlQueryInfoMarshaler());
}
