private static void Main(string[] args)
{
using (var log = new EnterExitLogger(s_log, Level.Info)) {
try {
var assembly = Assembly.LoadFile(args[0]);
if (args.Length > 1)
{
for (var i = 1; i < args.Length; i++)
{
if (Directory.Exists(args[i]))
{
var assemblies = Directory.GetFiles(args[i], "*.dll");
foreach (var asm in assemblies)
{
Assembly.LoadFile(asm);
}
}
else
{
Assembly.LoadFile(args[i]);
}
}
}
SoapClientTypeSerializer.DeserializeClientTypes(assembly);
} catch (Exception exc) {
s_log.Error(exc);
}
}
}
/// <summary>
/// Deserialisiert für den WebService-Proxytyp <paramref name="webServiceType"/> den zugehörigen SoapClientType und
/// registriert diesen im statischen Cache von <see cref="WebClientProtocol"/>.
/// </summary>
/// <param name="webServiceType">Der WebService-Proxytyp.</param>
public static void DeserializeClientType(Type webServiceType)
{
using (var log = new EnterExitLogger(s_log, Level.Info, "webServiceType = {0}", webServiceType)) {
if (!IsCached(webServiceType))
{
var filename = GetSerializerPath(webServiceType);
if (File.Exists(filename))
{
var formatter = new BinaryFormatter();
var webClientProtocolReflector = new TypeReflector(typeof(WebClientProtocol));
var cache = webClientProtocolReflector.GetField("cache");
var cacheReflector = new TypeReflector(cache.GetType());
//debug: var cacheHashtable = (Hashtable)cacheReflector.GetField(cache, "cache");
object deserializedClientType = null;
using (var stream = new FileStream(filename, FileMode.Open)) {
deserializedClientType = TypeSerializer.Deserialize(formatter, stream);
webClientProtocolReflector.Invoke("AddToCache(System.Type, System.Object)",
new object[] { webServiceType, deserializedClientType });
log.Log("added to WebClient cache: {0}", deserializedClientType);
}
}
}
}
}
public FieldReflector(Type type, string fieldName, BindingFlags bindingFlags)
: base(type, fieldName, bindingFlags)
{
using (var log = new EnterExitLogger(s_log, "type = {0}, fieldName = {1}, bindingFlags = {2}", type, fieldName, bindingFlags)) {
Info = type.GetField(fieldName, bindingFlags);
}
}
public TypeReflector(Type type)
{
using (var log = new EnterExitLogger(s_log, Level.Info, "type = {0}", type)) {
m_type = type;
m_fields = new FieldDict();
m_methods = new MethodDict();
m_staticMethods = new MethodDict();
var fields = m_type.GetFields(MemberReflector.AllDeclared);
foreach (var fi in fields)
{
m_fields.Add(fi.Name, new FieldReflector(fi));
}
var methods = m_type.GetMethods(MemberReflector.PrivateInstanceDeclared);
foreach (var mi in methods)
{
m_methods.Add(BuildMethodSignature(mi), new MethodReflector(mi));
}
methods = m_type.GetMethods(MemberReflector.AllStaticDeclared);
foreach (var mi in methods)
{
m_staticMethods.Add(BuildMethodSignature(mi), new MethodReflector(mi));
}
}
}
public ConstructorReflector(ConstructorInfo info)
: base(info)
{
using (var log = new EnterExitLogger(s_log, "info = {0}", info)) {
SetupConstructorInfo();
}
}
/// <summary>
/// Serialisiert den Objektgraph <param name="objectGraph"/> mit Hilfe des
/// angegebenen Formatters <paramref name="formatter"/> auf den Ausgabe-Stream <paramref name="stream"/>.
/// </summary>
/// <param name="formatter">The formatter.</param>
/// <param name="stream">The stream.</param>
/// <param name="objectGraph">The object graph.</param>
public static void Serialize(IFormatter formatter, Stream stream, object objectGraph)
{
using (var log = new EnterExitLogger(s_log, Level.Info, "objectGraph = {0}, type = {1}", objectGraph,
objectGraph as TypeSerializer != null ? ((TypeSerializer)objectGraph).m_type.FullName : "-")) {
formatter.Serialize(stream, objectGraph);
}
}
/// <summary>
/// Initialisiert eine neue Instanz der class <see cref="TypeSerializer"/> für das
/// nicht serialisierbare Objekt <paramref name="instance"/> für eine Serialisierung mittles
/// Reflection.
/// </summary>
/// <param name="instance">The instance.</param>
private TypeSerializer(object instance)
{
using (var log = new EnterExitLogger(s_log, "instance = {0}", instance)) {
m_instance = instance;
m_type = m_instance.GetType();
m_fields = new FieldSerializerDict();
m_constructors = new ConstructorReflectorDict();
foreach (var ci in m_type.GetConstructors(MemberReflector.AllInstanceDeclared))
{
var ctor = new ConstructorReflector(ci);
m_constructors.Add(TypeReflector.BuildMethodSignature(ci), ctor);
if (ctor.IsDefaultConstructor)
{
m_defaultConstructor = ctor;
}
}
var fields = m_type.GetFields(MemberReflector.AllInstanceDeclared);
foreach (var fi in fields)
{
var fieldValue = fi.GetValue(m_instance);
fieldValue = CreateSerializerWrapper(fieldValue);
m_fields.Add(fi.Name, new FieldSerializer(fi, fieldValue));
}
}
}
/// <summary>
/// Serializes the type of the client.
/// </summary>
/// <param name="webServiceType">Type of the web service.</param>
public static void SerializeClientType(Type webServiceType)
{
using (var log = new EnterExitLogger(s_log, Level.Info, "webServiceType = {0}", webServiceType)) {
IFormatter formatter = new BinaryFormatter();
using (var stream = new FileStream(GetSerializerPath(webServiceType), FileMode.OpenOrCreate)) {
//
// WebService-Proxy instantiieren -> SoapClientType wird über Reflection erzeugt
//
var ce = new ConstructorEventArgs(webServiceType);
if (Constructing != null)
{
Constructing(null, ce);
}
var ctor = new ConstructorReflector(webServiceType, ce.Types, MemberReflector.AllInstanceDeclared);
var webServiceInstance = ctor.Invoke(ce.Args);
//
// SoapClientType-Field ermitteln und serialisieren
//
var reflectedClientType = s_clientTypeReflector.GetValue(webServiceInstance);
var serializer = (TypeSerializer)TypeSerializer.CreateSerializerWrapper(reflectedClientType);
TypeSerializer.Serialize(formatter, stream, serializer);
}
}
}
public MethodReflector(Type type, string methodName, BindingFlags bindingFlags)
: base(type, methodName, bindingFlags)
{
using (var log = new EnterExitLogger(s_log, "type = {0}, methodName = {1}, bindingFlags = {2}", type, methodName, bindingFlags)) {
Info = type.GetMethod(methodName, bindingFlags);
}
}
public ConstructorReflector(Type type, Type[] types, BindingFlags bindingFlags)
: base(type, ".ctor", bindingFlags)
{
using (var log = new EnterExitLogger(s_log, "type = {0}, bindingFlags = {1}", type, bindingFlags)) {
Info = type.GetConstructor(bindingFlags, null, types, null);
SetupConstructorInfo();
}
}
public void GetObjectData(SerializationInfo info, StreamingContext context)
{
using (var log = new EnterExitLogger(s_log, "type = {0} [assembly: {1}], m_fields = {2}", m_type, m_type.Assembly, m_fields)) {
info.AddValue("m_type", m_type);
info.AddValue("m_fields", m_fields);
info.AddValue("m_constructors", m_constructors);
info.AddValue("m_defaultConstructor", m_defaultConstructor);
}
}
protected TypeSerializer(SerializationInfo si, StreamingContext context)
{
using (var log = new EnterExitLogger(s_log, "si = {0}", si)) {
m_type = (Type)si.GetValue("m_type", typeof(Type));
m_fields = (FieldSerializerDict)si.GetValue("m_fields", typeof(FieldSerializerDict));
m_constructors = (ConstructorReflectorDict)si.GetValue("m_constructors", typeof(ConstructorReflectorDict));
m_defaultConstructor = (ConstructorReflector)si.GetValue("m_defaultConstructor", typeof(ConstructorReflector));
}
}
/// <summary>
/// Serialisiert für alle WebService-Proxyklassen die internen SoapClientType-Instanzen in binäre Files.
/// </summary>
/// <param name="assembly">Die Assembly mit den WebService-Proxyklassen.</param>
public static void SerializeClientTypes(Assembly assembly)
{
using (var log = new EnterExitLogger(s_log, Level.Info, "assembly = {0}", assembly)) {
var webServiceTypes = GetWebserviceTypes(assembly);
foreach (var webServiceType in webServiceTypes)
{
SerializeClientType(webServiceType);
}
}
}
public static string BuildMethodSignature(MethodBase methodBase)
{
using (var log = new EnterExitLogger(s_log, "methodBase = {0}", methodBase)) {
var parameterTypes = new TypeList();
foreach (var pi in methodBase.GetParameters())
{
parameterTypes.Add(pi.ParameterType);
}
var types = parameterTypes.ToArray();
return(BuildMethodSignature(methodBase.Name, types));
}
}
public object Invoke(object[] parameters)
{
using (var log = new EnterExitLogger(s_log, "parameters = {0}", parameters)) {
if (IsDefaultConstructor)
{
return(Info.Invoke(null));
}
else
{
return(Info.Invoke(parameters));
}
}
}
/// <summary>
/// Deserialisiert einen WebService-Proxytyp (SoapHttpClientProtocol) mit Hilfe des angegebenen
/// Formatters <paramref name="formatter"/> vom Eingabe-Stream <paramref name="stream"/>.
/// </summary>
/// <param name="formatter">The formatter.</param>
/// <param name="stream">The stream.</param>
/// <param name="webServiceType">Type of the web service.</param>
/// <returns></returns>
public static object Deserialize(IFormatter formatter, Stream stream)
{
using (var log = new EnterExitLogger(s_log, Level.Info)) {
var typeSerializer = (TypeSerializer)formatter.Deserialize(stream);
var constructors = typeSerializer.m_type.GetConstructors(MemberReflector.AllInstanceDeclared);
var ctor = new ConstructorReflector(typeSerializer.m_type, new Type[] { typeof(Type) }, MemberReflector.AllInstanceDeclared);
var rval = ctor.Invoke(new object[] { typeof(EmptyWebService) });
typeSerializer.Deserialize(rval);
return(rval);
}
}
public object Invoke(string methodName, object[] parameters)
{
using (var log = new EnterExitLogger(s_log, Level.Info, "methodName = {0}, parameters = {1}", methodName, parameters)) {
if (String.IsNullOrEmpty(methodName))
{
throw new ArgumentNullException("methodName");
}
if (!m_staticMethods.ContainsKey(methodName))
{
throw new ArgumentException(string.Format("Type {0} has no such method.", m_type), "methodName");
}
return(m_staticMethods[methodName].Invoke(null, parameters));
}
}
public static string BuildMethodSignature(string name, Type[] parameterTypes)
{
using (var log = new EnterExitLogger(s_log, "name = {0}, parameterTypes = {1}", name, parameterTypes)) {
var sb = new StringBuilder(name);
sb.Append("(");
var first = true;
foreach (var type in parameterTypes)
{
if (!first)
{
sb.Append(", ");
}
sb.Append(type.FullName);
first = false;
}
sb.Append(")");
return(sb.ToString());
}
}
public MethodReflector(MethodInfo methodInfo)
: base(methodInfo)
{
using (var log = new EnterExitLogger(s_log, "methodInfo = {0}", methodInfo)) {
}
}
/// <summary>
/// Deserializes die angegebenen instance.
/// </summary>
/// <param name="instance">The instance.</param>
private object Deserialize(object instance)
{
using (var log = new EnterExitLogger(s_log, "instance = {0}, type = {1}", instance, m_type)) {
if (instance == null)
{
if (DefaultConstructor != null)
{
instance = DefaultConstructor.Invoke(null);
}
else
{
if (m_type.IsArray)
{
var elementType = m_type.GetElementType();
var arrayCtor = GetConstructor(".ctor(System.Int32)");
//
// Dummy: Array mit einem Element anlegen
//
var array = (object[])arrayCtor.Invoke(new object[] { 1 });
if (!elementType.IsAbstract)
{
//ConstructorReflector elCtor = new ConstructorReflector(elementType, MemberReflector.AllInstanceDeclared);
//object element = elCtor.Invoke(null);
//array[0] = element;
}
instance = array;
}
else if (m_type == typeof(LogicalMethodInfo))
{
//
// Achtung: Spezialbehandlung, da die Klasse LogicalMethodInfo nur einen Konstruktor
// mit einem MethodInfo-Parameter hat! -> wir erzeugen einen Dummy-Konstruktorparameter;
// die konkreten Member werden bei der Deserialisierung gesetzt.
//
var tr = new TypeReflector(typeof(DummyInfoWebService));
var mi = typeof(DummyInfoWebService).GetMethod("getString");
//var rtmiCtor = new ConstructorReflector(Type.GetType("System.Reflection.RuntimeMethodInfo"));
//var rtmi = rtmiCtor.Invoke(null);
var ctorSignature = TypeReflector.BuildMethodSignature(".ctor", new Type[] { Type.GetType("System.Reflection.MethodInfo") });
var ctor = GetConstructor(ctorSignature);
instance = ctor.Invoke(new object[] { mi });
}
else
{
throw new InvalidOperationException(string.Format("Type {0} has no default constructor", m_type));
}
}
}
//
// Deseralisierung der Member
//
foreach (var field in m_fields.Values)
{
var fieldValue = field.Value;
var fieldSerializer = field.Value as TypeSerializer;
if (fieldSerializer != null)
{
var instanceFieldValue = fieldSerializer.Deserialize();
field.SetValue(instance, instanceFieldValue);
}
else if (field.Value != null)
{
if (field.Value is Hashtable)
{
var ht = new Hashtable();
foreach (DictionaryEntry de in ((Hashtable)field.Value))
{
var key = de.Key;
var value = de.Value;
if (key is TypeSerializer)
{
key = ((TypeSerializer)key).Deserialize();
}
if (value is TypeSerializer)
{
value = ((TypeSerializer)value).Deserialize();
}
ht.Add(key, value);
}
field.SetValue(instance, ht);
}
else if (field.Info.FieldType.IsArray)
{
var fieldValues = (object[])field.Value;
var ctor = new ConstructorReflector(field.Info.FieldType, new Type[] { typeof(int) }, MemberReflector.AllInstanceDeclared);
var array = (object[])ctor.Invoke(new object[] { fieldValues.Length });
for (var i = 0; i < fieldValues.Length; i++)
{
if (fieldValues[i] is TypeSerializer)
{
array[i] = ((TypeSerializer)fieldValues[i]).Deserialize();
}
else
{
array[i] = fieldValues[i];
}
}
field.SetValue(instance, array);
}
else
{
// regular field
field.SetValue(instance, field.Value);
}
}
}
return(instance);
}
}
/// <summary>
/// Entry point of the application.
/// </summary>
/// <param name="args">The args.</param>
/// <remarks>
/// args[0]: assembly containing the web service proxies.
/// args[1]: web service proxy constructor types (type names)
/// </remarks>
static void Main(string[] args)
{
using (var log = new EnterExitLogger(s_log, Level.Info)) {
#if (false)
Type[] exportedTypes = typeof(AkteWebService).Assembly.GetExportedTypes();
List <Type> webServiceTypes = new List <Type>();
foreach (Type type in exportedTypes)
{
if (type.IsAbstract)
{
continue;
}
WebServiceBindingAttribute[] serviceBindingAttributes = (WebServiceBindingAttribute[])type.GetCustomAttributes(typeof(WebServiceBindingAttribute), false);
if (serviceBindingAttributes != null && serviceBindingAttributes.Length == 1)
{
webServiceTypes.Add(type);
}
}
foreach (Type webServiceType in webServiceTypes)
{
SoapClientTypeSerializer.SerializeClientType(webServiceType);
}
#endif
try {
AppDomain.CurrentDomain.AssemblyResolve += CurrentDomainAssemblyResolve;
var assembly = Assembly.LoadFile(args[0]);
s_modelDirectory = Path.GetDirectoryName(assembly.Location);
var serializerFileName = assembly.Location;
serializerFileName = Path.ChangeExtension(serializerFileName, ".XmlSerializers.dll");
if (File.Exists(serializerFileName))
{
var serializerAssembly = Assembly.LoadFile(serializerFileName);
}
if (args.Length > 1)
{
var constructorTypes = args[1].Split(new char[] { ';' });
foreach (var constructorType in constructorTypes)
{
var typeParts = constructorType.Split(new char[] { ',' });
Type type;
if (typeParts.Length > 1)
{
var asmName = typeParts[1].Trim();
var asmPath = Path.Combine(s_modelDirectory, asmName);
asmPath = Path.ChangeExtension(asmPath, ".dll");
//Assembly asm = Assembly.LoadFrom(Path.Combine(Path.GetDirectoryName(assembly.Location), "ObjectManagement.dll"));
var asm = Assembly.LoadFile(asmPath);
type = asm.GetType(typeParts[0]);
}
else
{
type = Type.GetType(constructorType);
}
if (type != null)
{
s_constructorTypes.Add(type);
}
}
}
var currentDirectory = Environment.CurrentDirectory;
try {
Environment.CurrentDirectory = Path.GetDirectoryName(assembly.Location);
SoapClientTypeSerializer.Constructing +=
new EventHandler <ConstructorEventArgs>(SoapClientTypeSerializerConstructing);
SoapClientTypeSerializer.SerializeClientTypes(assembly);
} finally {
Environment.CurrentDirectory = currentDirectory;
}
} catch (Exception exc) {
log.Error(exc);
}
}
}
public FieldReflector(MemberInfo fieldInfo)
: base(fieldInfo)
{
using (var log = new EnterExitLogger(s_log, "fieldInfo = {0}", fieldInfo)) {
}
}
