public static byte[] GenerateStub(jlClass c) { MemoryStream mem = new MemoryStream(); #if !FIRST_PASS bool includeNonPublicInterfaces = !"true".Equals(global::java.lang.Props.props.getProperty("ikvm.stubgen.skipNonPublicInterfaces"), StringComparison.OrdinalIgnoreCase); IKVM.StubGen.StubGenerator.WriteClass(mem, TypeWrapper.FromClass(c), includeNonPublicInterfaces, false, false, true); #endif return mem.ToArray(); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::org.drools.builder.conf.@__KnowledgeBuilderOption.staticClass = @__class; global::org.drools.builder.conf.@__KnowledgeBuilderOption._getPropertyName0 = @__env.GetMethodID(global::org.drools.builder.conf.@__KnowledgeBuilderOption.staticClass, "getPropertyName", "()Ljava/lang/String;"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::java.lang.reflect.@__WildcardType.staticClass = @__class; global::java.lang.reflect.@__WildcardType.j4n_getLowerBounds0 = @__env.GetMethodID(global::java.lang.reflect.@__WildcardType.staticClass, "getLowerBounds", "()[Ljava/lang/reflect/Type;"); global::java.lang.reflect.@__WildcardType.j4n_getUpperBounds1 = @__env.GetMethodID(global::java.lang.reflect.@__WildcardType.staticClass, "getUpperBounds", "()[Ljava/lang/reflect/Type;"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::org.drools.builder.@__KnowledgeBuilderError.staticClass = @__class; global::org.drools.builder.@__KnowledgeBuilderError._getMessage0 = @__env.GetMethodID(global::org.drools.builder.@__KnowledgeBuilderError.staticClass, "getMessage", "()Ljava/lang/String;"); global::org.drools.builder.@__KnowledgeBuilderError._getErrorLines1 = @__env.GetMethodID(global::org.drools.builder.@__KnowledgeBuilderError.staticClass, "getErrorLines", "()[I"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::robocode.control.events.BattleFinishedEvent.staticClass = @__class; global::robocode.control.events.BattleFinishedEvent.j4n_isAborted0 = @__env.GetMethodID(global::robocode.control.events.BattleFinishedEvent.staticClass, "isAborted", "()Z"); global::robocode.control.events.BattleFinishedEvent.j4n__ctorBattleFinishedEvent1 = @__env.GetMethodID(global::robocode.control.events.BattleFinishedEvent.staticClass, "<init>", "(Z)V"); }
internal object ToMethodOrConstructor(bool copy) { #if FIRST_PASS return null; #else object method = reflectionMethod; if (method == null) { Link(); ClassLoaderWrapper loader = this.DeclaringType.GetClassLoader(); TypeWrapper[] argTypes = GetParameters(); java.lang.Class[] parameterTypes = new java.lang.Class[argTypes.Length]; for (int i = 0; i < argTypes.Length; i++) { parameterTypes[i] = argTypes[i].EnsureLoadable(loader).ClassObject; } java.lang.Class[] checkedExceptions = GetExceptions(); if (this.Name == StringConstants.INIT) { method = new java.lang.reflect.Constructor( this.DeclaringType.ClassObject, parameterTypes, checkedExceptions, (int)this.Modifiers | (this.IsInternal ? 0x40000000 : 0), Array.IndexOf(this.DeclaringType.GetMethods(), this), this.DeclaringType.GetGenericMethodSignature(this), null, null ); } else { method = new java.lang.reflect.Method( this.DeclaringType.ClassObject, this.Name, parameterTypes, this.ReturnType.EnsureLoadable(loader).ClassObject, checkedExceptions, (int)this.Modifiers | (this.IsInternal ? 0x40000000 : 0), Array.IndexOf(this.DeclaringType.GetMethods(), this), this.DeclaringType.GetGenericMethodSignature(this), null, null, null ); } lock (this) { if (reflectionMethod == null) { reflectionMethod = method; } else { method = reflectionMethod; } } } if (copy) { java.lang.reflect.Constructor ctor = method as java.lang.reflect.Constructor; if (ctor != null) { return ctor.copy(); } return ((java.lang.reflect.Method)method).copy(); } return method; #endif }
public override global::System.Object getParameterTypes() { org.xmlvm._nMemberInfoAdapter<global::System.Reflection.MethodInfo, java.lang.reflect.Constructor._nImpl> adapter = (org.xmlvm._nMemberInfoAdapter<global::System.Reflection.MethodInfo, java.lang.reflect.Constructor._nImpl>) this._faddress; global::System.Reflection.MethodInfo methodInfo = adapter.getMemberInfoAdaptee(); global::System.Reflection.ParameterInfo[] parameterInfos = methodInfo.GetParameters(); java.lang.Class[] parameterJavaTypes = new java.lang.Class[parameterInfos.Length]; for (int i=0; i<parameterInfos.Length; i++) { global::System.Type parameterNativeType = parameterInfos[i].ParameterType; parameterJavaTypes[i] = org.xmlvm._nTIB.getClass(parameterNativeType); } org.xmlvm._nArrayAdapter<object> result = new org.xmlvm._nArrayAdapter<object>(parameterJavaTypes); return result; }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::robocode.exception.AbortedException.staticClass = @__class; global::robocode.exception.AbortedException.j4n__ctorAbortedException0 = @__env.GetMethodID(global::robocode.exception.AbortedException.staticClass, "<init>", "()V"); global::robocode.exception.AbortedException.j4n__ctorAbortedException1 = @__env.GetMethodID(global::robocode.exception.AbortedException.staticClass, "<init>", "(Ljava/lang/String;)V"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::org.drools.runtime.rule.@__Operator.staticClass = @__class; global::org.drools.runtime.rule.@__Operator._getOperatorString0 = @__env.GetMethodID(global::org.drools.runtime.rule.@__Operator.staticClass, "getOperatorString", "()Ljava/lang/String;"); global::org.drools.runtime.rule.@__Operator._isNegated1 = @__env.GetMethodID(global::org.drools.runtime.rule.@__Operator.staticClass, "isNegated", "()Z"); }
public static bool IsDynamic(jlClass clazz) { return TypeWrapper.FromClass(clazz) is DynamicTypeWrapper; }
public static Assembly GetAssemblyFromClass(jlClass clazz) { TypeWrapper wrapper = TypeWrapper.FromClass(clazz); AssemblyClassLoader_ acl = wrapper.GetClassLoader() as AssemblyClassLoader_; return acl != null ? acl.GetAssembly(wrapper) : null; }
public static bool isClassDeprecated(jlClass clazz) { Type type = TypeWrapper.FromClass(clazz).TypeAsTBD; // we need to check type for null, because ReflectionOnly // generated delegate inner interfaces don't really exist return type != null && type.IsDefined(typeof(ObsoleteAttribute), false); }
public static string getAssemblyName(jlClass c) { TypeWrapper wrapper = TypeWrapper.FromClass(c); ClassLoaderWrapper loader = wrapper.GetClassLoader(); IKVM.Internal.AssemblyClassLoader acl = loader as IKVM.Internal.AssemblyClassLoader; if(acl != null) { return acl.GetAssembly(wrapper).FullName; } else { return ((IKVM.Internal.GenericClassLoader)loader).GetName(); } }
public void setClass(java.lang.Class myClass) { this.myClass = myClass; }
public _ResponseDeserializer_271(InternalArangoDatabase <E, R, C> _enclosing, java.lang.Class type) { this._enclosing = _enclosing; this.type = type; }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::[email protected].@__KnowledgeBaseEvent.staticClass = @__class; global::[email protected].@__KnowledgeBaseEvent._getKnowledgeBase0 = @__env.GetMethodID(global::[email protected].@__KnowledgeBaseEvent.staticClass, "getKnowledgeBase", "()Lorg/drools/KnowledgeBase;"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::java.lang.@__Comparable.staticClass = @__class; global::java.lang.@__Comparable._compareTo0 = @__env.GetMethodID(global::java.lang.@__Comparable.staticClass, "compareTo", "(Ljava/lang/Object;)I"); }
private static PlTerm typeToSpec(Class type) { if (type == null) return PLNULL; if (type.IsArray && type.HasElementType) { if (type.GetArrayRank() != 1) { return PlC("arrayOf", typeToSpec(type.GetElementType()), ToProlog(type.GetArrayRank())); } return PlC("arrayOf", typeToSpec(type.GetElementType())); } if (type.IsGenericParameter) { Type[] gt = type.GetGenericParameterConstraints(); return PlC("<" + type.FullName ?? type.Name + ">", ToPlTermVSpecs(gt)); } if (type.IsPointer) { Type gt = type.GetElementType(); return PlC("pointer", typeToSpec(gt)); } if (type.IsByRef) { Type gt = type.GetElementType(); return PlC("byref", typeToSpec(gt)); } // @todo if false , use IsGenericType if (false) if (typeof(Nullable<>).IsAssignableFrom(type)) { Error("@todo Not Implemented NULLABLE"); Type gt = type.GetElementType(); return PlC("nullable", typeToSpec(gt)); } if (type.IsGenericType ) { Type gt = type.GetGenericTypeDefinition(); Type[] gtp = type.GetGenericArguments(); PlTermV vt = ToPlTermVSpecs(gtp); string typeName = type.FullName ?? type.Name; int gtpLength = gtp.Length; int indexOf = typeName.IndexOf("`" + gtpLength); if (indexOf > 0) { typeName = typeName.Substring(0, indexOf); } else { Debug("cant chop arity {0} off string '{1}' ", gtpLength, typeName); } return PlC(typeName, vt); } if (type.HasElementType) { string named = typeToName(type); Error("@todo Not Implemented " + named); Type gt = type.GetElementType(); if (gt == type) gt = typeof(object); return PlC("elementType", PlTerm.PlAtom(named), typeToSpec(gt)); } if (type.IsSpecialName || string.IsNullOrEmpty(type.Name) || string.IsNullOrEmpty(type.FullName) || string.IsNullOrEmpty(type.Namespace)) { string named = typeToName(type); Error("@todo Not Implemented " + named); Type gt = type.UnderlyingSystemType; if (gt == type) gt = typeof (object); return PlC("static", PlTerm.PlAtom(named), typeToSpec(gt)); } return PlTerm.PlAtom(typeToName(type)); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::org.drools.runtime.@__Calendars.staticClass = @__class; global::org.drools.runtime.@__Calendars._get0 = @__env.GetMethodID(global::org.drools.runtime.@__Calendars.staticClass, "get", "(Ljava/lang/String;)Lorg/drools/time/Calendar;"); global::org.drools.runtime.@__Calendars._set1 = @__env.GetMethodID(global::org.drools.runtime.@__Calendars.staticClass, "set", "(Ljava/lang/String;Lorg/drools/time/Calendar;)V"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::[email protected].@__ActivationEvent.staticClass = @__class; global::[email protected].@__ActivationEvent._getKnowledgeRuntime0 = @__env.GetMethodID(global::[email protected].@__ActivationEvent.staticClass, "getKnowledgeRuntime", "()Lorg/drools/runtime/KnowledgeRuntime;"); global::[email protected].@__ActivationEvent._getActivation1 = @__env.GetMethodID(global::[email protected].@__ActivationEvent.staticClass, "getActivation", "()Lorg/drools/runtime/rule/Activation;"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::net.sf.jni4net.jni.__IJvmProxy.staticClass = @__class; global::net.sf.jni4net.jni.__IJvmProxy._JvmHandle0 = @__env.GetMethodID(global::net.sf.jni4net.jni.__IJvmProxy.staticClass, "getJvmHandle", "()J"); global::net.sf.jni4net.jni.__IJvmProxy._Init2 = @__env.GetMethodID(global::net.sf.jni4net.jni.__IJvmProxy.staticClass, "Init", "(Lsystem/Object;J)V"); }
internal override sealed TypeWrapper DefineClassImpl(Dictionary<string, TypeWrapper> types, ClassFile f, ClassLoaderWrapper classLoader, object protectionDomain) { DynamicTypeWrapper type; #if STATIC_COMPILER type = new AotTypeWrapper(f, (CompilerClassLoader)classLoader); #else type = new DynamicTypeWrapper(f, classLoader); #endif // this step can throw a retargettable exception, if the class is incorrect bool hasclinit; type.CreateStep1(out hasclinit); // now we can allocate the mangledTypeName, because the next step cannot fail string mangledTypeName = AllocMangledName(f.Name); // This step actually creates the TypeBuilder. It is not allowed to throw any exceptions, // if an exception does occur, it is due to a programming error in the IKVM or CLR runtime // and will cause a CriticalFailure and exit the process. type.CreateStep2NoFail(hasclinit, mangledTypeName); lock(types) { // in very extreme conditions another thread may have beaten us to it // and loaded (not defined) a class with the same name, in that case // we'll leak the the Reflection.Emit defined type. Also see the comment // in ClassLoaderWrapper.RegisterInitiatingLoader(). TypeWrapper race; types.TryGetValue(f.Name, out race); if(race == null) { lock(dynamicTypes) { Debug.Assert(dynamicTypes.ContainsKey(mangledTypeName) && dynamicTypes[mangledTypeName] == null); dynamicTypes[mangledTypeName] = type; } types[f.Name] = type; #if !STATIC_COMPILER && !FIRST_PASS java.lang.Class clazz = new java.lang.Class(null); #if __MonoCS__ TypeWrapper.SetTypeWrapperHack(clazz, type); #else clazz.typeWrapper = type; #endif clazz.pd = (java.security.ProtectionDomain)protectionDomain; type.SetClassObject(clazz); #endif } else { throw new LinkageError("duplicate class definition: " + f.Name); } } return type; }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::robocode.control.events.TurnEndedEvent.staticClass = @__class; global::robocode.control.events.TurnEndedEvent.j4n_getTurnSnapshot0 = @__env.GetMethodID(global::robocode.control.events.TurnEndedEvent.staticClass, "getTurnSnapshot", "()Lrobocode/control/snapshot/ITurnSnapshot;"); global::robocode.control.events.TurnEndedEvent.j4n__ctorTurnEndedEvent1 = @__env.GetMethodID(global::robocode.control.events.TurnEndedEvent.staticClass, "<init>", "(Lrobocode/control/snapshot/ITurnSnapshot;)V"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::java.nio.BufferOverflowException.staticClass = @__class; global::java.nio.BufferOverflowException.j4n__ctorBufferOverflowException0 = @__env.GetMethodID(global::java.nio.BufferOverflowException.staticClass, "<init>", "()V"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::java.lang.@__Cloneable.staticClass = @__class; }
public ClassConfiguration(java.lang.Class hostClass, java.lang.Class[] domClasses, bool jsObject) : this(new com.gargoylesoftware.htmlunit.javascript.configuration.ClassConfiguration(hostClass, domClasses, jsObject)) { }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::PaymentGateway.@__BatchRecord.staticClass = @__class; }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::org.drools.definition.@__KnowledgeDefinition.staticClass = @__class; }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::net.sf.robocode.core.ContainerBase.staticClass = @__class; global::net.sf.robocode.core.ContainerBase.j4n_getComponent0 = @__env.GetStaticMethodID(global::net.sf.robocode.core.ContainerBase.staticClass, "getComponent", "(Ljava/lang/Class;)Ljava/lang/Object;"); global::net.sf.robocode.core.ContainerBase.j4n_instance1 = @__env.GetStaticFieldID(global::net.sf.robocode.core.ContainerBase.staticClass, "instance", "Lnet/sf/robocode/core/ContainerBase;"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::java.io.@__Closeable.staticClass = @__class; global::java.io.@__Closeable._close0 = @__env.GetMethodID(global::java.io.@__Closeable.staticClass, "close", "()V"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::ClassLib.@__CommunicationManager.staticClass = @__class; }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::java.lang.NoClassDefFoundError.staticClass = @__class; global::java.lang.NoClassDefFoundError.@__ctorNoClassDefFoundError0 = @__env.GetMethodID(global::java.lang.NoClassDefFoundError.staticClass, "<init>", "(Ljava/lang/String;)V"); global::java.lang.NoClassDefFoundError.@__ctorNoClassDefFoundError1 = @__env.GetMethodID(global::java.lang.NoClassDefFoundError.staticClass, "<init>", "()V"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::org.drools.runtime.@__CommandExecutor.staticClass = @__class; global::org.drools.runtime.@__CommandExecutor._execute0 = @__env.GetMethodID(global::org.drools.runtime.@__CommandExecutor.staticClass, "execute", "(Lorg/drools/command/Command;)Ljava/lang/Object;"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::System.IO.@__Stream.staticClass = @__class; }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::robocode.control.events.BattleErrorEvent.staticClass = @__class; global::robocode.control.events.BattleErrorEvent.j4n_getError0 = @__env.GetMethodID(global::robocode.control.events.BattleErrorEvent.staticClass, "getError", "()Ljava/lang/String;"); global::robocode.control.events.BattleErrorEvent.j4n__ctorBattleErrorEvent1 = @__env.GetMethodID(global::robocode.control.events.BattleErrorEvent.staticClass, "<init>", "(Ljava/lang/String;)V"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::robocode.control.events.TurnStartedEvent.staticClass = @__class; global::robocode.control.events.TurnStartedEvent.j4n__ctorTurnStartedEvent0 = @__env.GetMethodID(global::robocode.control.events.TurnStartedEvent.staticClass, "<init>", "()V"); }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::ClassLib.@__TopicsConfiguration.staticClass = @__class; }
private static string typeToName(Class type) { if (type.IsArray && type.HasElementType) { return typeToSpec(type.GetElementType()) + "[]"; } lock (ShortNameType) { string shortName; if (TypeShortName.TryGetValue(type, out shortName)) { return shortName; } string typeName = type.Name; Type otherType; if (ShortNameType.TryGetValue(type.Name, out otherType)) { if (type == otherType) { return typeName; } return type.FullName; } ShortNameType[typeName] = type; TypeShortName[type] = typeName; return typeName; } }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::robocode.control.snapshot.@__IDebugProperty.staticClass = @__class; global::robocode.control.snapshot.@__IDebugProperty.j4n_getValue0 = @__env.GetMethodID(global::robocode.control.snapshot.@__IDebugProperty.staticClass, "getValue", "()Ljava/lang/String;"); global::robocode.control.snapshot.@__IDebugProperty.j4n_getKey1 = @__env.GetMethodID(global::robocode.control.snapshot.@__IDebugProperty.staticClass, "getKey", "()Ljava/lang/String;"); }
public static object newAnnotationInvocationHandler(jlClass type, object memberValues) { #if FIRST_PASS return null; #else return new global::sun.reflect.annotation.AnnotationInvocationHandler(type, (global::java.util.Map)memberValues); #endif }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::System.Reflection.@__FieldInfo.staticClass = @__class; }
public static Type getInstanceTypeFromClass(jlClass clazz) { TypeWrapper wrapper = TypeWrapper.FromClass(clazz); if(wrapper.IsRemapped && wrapper.IsFinal) { return wrapper.TypeAsTBD; } return wrapper.TypeAsBaseType; }
private static void InitJNI(global::net.sf.jni4net.jni.JNIEnv @__env, java.lang.Class @__class) { global::java.lang.@__Iterable.staticClass = @__class; global::java.lang.@__Iterable.j4n_iterator0 = @__env.GetMethodID(global::java.lang.@__Iterable.staticClass, "iterator", "()Ljava/util/Iterator;"); }
private java.lang.Class[] GetExceptions() { string[] classes = declaredExceptions; Type[] types = Type.EmptyTypes; if (classes == null) { // NOTE if method is a MethodBuilder, GetCustomAttributes doesn't work (and if // the method had any declared exceptions, the declaredExceptions field would have // been set) if (method != null && !(method is MethodBuilder)) { ThrowsAttribute attr = AttributeHelper.GetThrows(method); if (attr != null) { classes = attr.classes; types = attr.types; } } } if (classes != null) { java.lang.Class[] array = new java.lang.Class[classes.Length]; for (int i = 0; i < classes.Length; i++) { array[i] = this.DeclaringType.GetClassLoader().LoadClassByDottedName(classes[i]).ClassObject; } return array; } else { java.lang.Class[] array = new java.lang.Class[types.Length]; for (int i = 0; i < types.Length; i++) { array[i] = types[i]; } return array; } }
public void Initialize(bool tryUpdateCoreJar = true, string coreJarRemoteBaseUrl = "http://www.mkhx.cc/resources/lib/corejar", string javaHome = null) { OnLogging(TraceLevel.Info, string.Format("Initializing GameLauncherFacade...tryUpdateCoreJar = {0}", tryUpdateCoreJar)); var assemblyDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); var jarPath = Path.Combine(assemblyDir, coreJarFileName); OnLogging(TraceLevel.Info, string.Format("Local CoreJarPath = {0}", jarPath)); bool jarExists = File.Exists(jarPath); OnLogging(TraceLevel.Info, string.Format("Local CoreJarExists = {0}", jarExists)); var verPath = Path.Combine(assemblyDir, coreJarVersionFileName); OnLogging(TraceLevel.Info, string.Format("Local CoreJarVersionFilePath = {0}", verPath)); var verExists = File.Exists(verPath); OnLogging(TraceLevel.Info, string.Format("Local CoreJarVersionFileExists = {0}", verExists)); long existingVer = 0; if (jarExists && verExists) { var existingVerText = File.ReadAllText(verPath); var parseSuccess = long.TryParse(existingVerText, out existingVer); if (parseSuccess) { OnLogging(TraceLevel.Info, string.Format("Successfully get local core jar version: {0}", existingVer)); } else { OnLogging(TraceLevel.Warning, string.Format("Failed to get local core jar version! Invalid version text: {0}", existingVerText)); } } if (tryUpdateCoreJar || !jarExists) { OnLogging(TraceLevel.Info, "Trying to update local core jar with latest one on server."); using (WebClient client = new WebClient()) { try { var remoteVerUrl = coreJarRemoteBaseUrl + "/" + coreJarVersionFileName; long latestVer = long.MaxValue; try { OnLogging(TraceLevel.Info, string.Format("Downloading version file from {0}...", remoteVerUrl)); var latestVerText = client.DownloadString(remoteVerUrl); OnLogging(TraceLevel.Info, "Done!"); if (!long.TryParse(latestVerText, out latestVer)) { OnLogging(TraceLevel.Warning, string.Format("Server returns an invalid core jar file version: {0}. Force update...", latestVerText)); } } catch (Exception e) { OnLogging(TraceLevel.Error, string.Format("Failed to get remote core jar version: {0}", e)); OnLogging(TraceLevel.Info, "Force update!"); } OnLogging(TraceLevel.Info, string.Format("Remote core jar version: {0}", latestVer)); if (!jarExists || existingVer < latestVer) { OnLogging(TraceLevel.Info, "Trying to replace local core jar with remote one..."); var remoteCoreJarUrl = coreJarRemoteBaseUrl + "/" + coreJarFileName; OnLogging(TraceLevel.Info, string.Format("Downloading core jar file from {0}...", remoteCoreJarUrl)); client.DownloadFile(remoteCoreJarUrl, jarPath); OnLogging(TraceLevel.Info, "Done!"); var remoteCoreJarVerFileUrl = coreJarRemoteBaseUrl + "/" + coreJarVersionFileName; OnLogging(TraceLevel.Info, string.Format("Downloading core jar version file from {0}...", remoteCoreJarVerFileUrl)); client.DownloadFile(remoteCoreJarVerFileUrl, verPath); OnLogging(TraceLevel.Info, "Done!"); } else { OnLogging(TraceLevel.Info, "Local core jar file is already update-to-date."); } } catch (Exception e) { OnLogging(TraceLevel.Error, "Failed to update local core jar with remote one due to error: " + e.ToString()); if (!jarExists) { throw new InvalidOperationException("Core jar file does not exists either on server or at local.", e); } } } } OnLogging(TraceLevel.Info, "Initializing JVM..."); var setup = new net.sf.jni4net.BridgeSetup(); if (!string.IsNullOrEmpty(javaHome)) { setup.JavaHome = javaHome; } setup.AddClassPath(jarPath); this.jvm = net.sf.jni4net.Bridge.CreateJVM(setup); this.facadeClass = this.jvm.FindClass("cfvbaibai/cardfantasy/game/launcher/GameLauncherFacade"); OnLogging(TraceLevel.Info, "JVM initialized!"); OnLogging(TraceLevel.Info, "Facade is fully initialized."); }