Example #1
0
 private void remove(copyer copyer)
 {
     if (copyer.CheckName())
     {
         removeNoCheck(copyer);
     }
 }
Example #2
0
        /// <summary>
        /// 删除守护进程
        /// </summary>
        /// <param name="copyer">文件信息</param>
        private void removeNoCheck(copyer copyer)
        {
            copyer cache;

            Monitor.Enter(guardLock);
            try
            {
                if (guards.TryGetValue(copyer.ProcessId, out cache))
                {
                    guards.Remove(copyer.ProcessId);
                }
            }
            finally { Monitor.Exit(guardLock); }
            if (cache != null)
            {
                cache.RemoveGuard();
                saveCache();
            }
        }
Example #3
0
 private void copyStart(copyer copyer)
 {
     if (copyer.CheckName())
     {
         bool isGuard;
         Monitor.Enter(guardLock);
         try
         {
             isGuard = guards.Remove(copyer.ProcessId);
         }
         finally { Monitor.Exit(guardLock); }
         if (isGuard)
         {
             saveCache();
         }
         log.Default.Add("启动文件复制 " + copyer.Process, new System.Diagnostics.StackFrame(), false);
         copyer.Copy();
     }
 }
Example #4
0
 private void guard(copyer copyer)
 {
     if (copyer.CheckName())
     {
         copyer cache;
         Monitor.Enter(guardLock);
         try
         {
             if (guards.TryGetValue(copyer.ProcessId, out cache))
             {
                 guards[copyer.ProcessId] = copyer;
             }
             else
             {
                 guards.Add(copyer.ProcessId, copyer);
             }
         }
         finally { Monitor.Exit(guardLock); }
         if (cache != null)
         {
             pub.Dispose(ref cache);
         }
         if (!copyer.Guard(this))
         {
             Monitor.Enter(guardLock);
             try
             {
                 if (guards.TryGetValue(copyer.ProcessId, out cache) && cache == copyer)
                 {
                     guards.Remove(copyer.ProcessId);
                 }
             }
             finally { Monitor.Exit(guardLock); }
         }
         saveCache();
     }
 }
Example #5
0
        static Copyer()
        {
            Type type = typeof(valueType), refType = type.MakeByRefType();

            if (!type.IsValueType)
            {
                memberwiseClone = (Func <valueType, object>)Delegate.CreateDelegate(typeof(Func <valueType, object>), typeof(object).GetMethod("MemberwiseClone", BindingFlags.Instance | BindingFlags.NonPublic));
            }
            if (type.IsArray)
            {
                if (type.GetArrayRank() == 1)
                {
                    Type copyerType = typeof(Copyer <>).MakeGenericType(type.GetElementType());
                    defaultCopyer       = (copyer)Delegate.CreateDelegate(typeof(copyer), copyerType.GetMethod("copyArray", BindingFlags.Static | BindingFlags.NonPublic, null, new Type[] { refType, type }, null));
                    defaultMemberCopyer = (memberMapCopyer)Delegate.CreateDelegate(typeof(memberMapCopyer), copyerType.GetMethod("copyArray", BindingFlags.Static | BindingFlags.NonPublic, null, new Type[] { refType, type, typeof(MemberMap) }, null));
                    return;
                }
                defaultCopyer       = noCopy;
                defaultMemberCopyer = noCopy;
                return;
            }
            if (type.IsEnum || type.IsPointer || type.IsInterface || typeof(Delegate).IsAssignableFrom(type))
            {
                isValueCopy = true;
                return;
            }
            foreach (AutoCSer.Metadata.AttributeMethod methodInfo in AutoCSer.Metadata.AttributeMethod.GetStatic(type))
            {
                if (methodInfo.Method.ReturnType == typeof(void))
                {
                    ParameterInfo[] parameters = methodInfo.Method.GetParameters();
                    if (parameters.Length == 3 && parameters[0].ParameterType == refType && parameters[1].ParameterType == type && parameters[2].ParameterType == typeof(MemberMap))
                    {
                        if (methodInfo.GetAttribute <CustomAttribute>() != null)
                        {
                            defaultCopyer       = customCopy;
                            defaultMemberCopyer = (memberMapCopyer)Delegate.CreateDelegate(typeof(memberMapCopyer), methodInfo.Method);
                            return;
                        }
                    }
                }
            }
            FieldIndex[] fields = MemberIndexGroup <valueType> .GetFields();

            if (fields.Length == 0)
            {
                defaultCopyer       = noCopy;
                defaultMemberCopyer = noCopy;
                return;
            }
#if NOJIT
            defaultCopyer       = new FieldCopyer(fields).Copyer();
            defaultMemberCopyer = new MemberMapFieldCopyer(fields).Copyer();
#else
            MemberDynamicMethod dynamicMethod          = new MemberDynamicMethod(type, new DynamicMethod("MemberCopyer", null, new Type[] { refType, type }, type, true));
            MemberDynamicMethod memberMapDynamicMethod = new MemberDynamicMethod(type, new DynamicMethod("MemberMapCopyer", null, new Type[] { refType, type, typeof(MemberMap) }, type, true));
            foreach (FieldIndex field in fields)
            {
                dynamicMethod.Push(field);
                memberMapDynamicMethod.PushMemberMap(field);
            }
            defaultCopyer       = (copyer)dynamicMethod.Create <copyer>();
            defaultMemberCopyer = (memberMapCopyer)memberMapDynamicMethod.Create <memberMapCopyer>();
#endif
        }
 /// <summary>
 /// 删除守护进程
 /// </summary>
 /// <param name="copyer">文件信息</param>
 private void removeNoCheck(copyer copyer)
 {
     copyer cache;
     Monitor.Enter(guardLock);
     try
     {
         if (guards.TryGetValue(copyer.ProcessId, out cache)) guards.Remove(copyer.ProcessId);
     }
     finally { Monitor.Exit(guardLock); }
     if (cache != null)
     {
         cache.RemoveGuard();
         saveCache();
     }
 }
 private void remove(copyer copyer)
 {
     if (copyer.CheckName()) removeNoCheck(copyer);
 }
 private void guard(copyer copyer)
 {
     if (copyer.CheckName())
     {
         copyer cache;
         Monitor.Enter(guardLock);
         try
         {
             if (guards.TryGetValue(copyer.ProcessId, out cache)) guards[copyer.ProcessId] = copyer;
             else guards.Add(copyer.ProcessId, copyer);
         }
         finally { Monitor.Exit(guardLock); }
         if (cache != null) pub.Dispose(ref cache);
         if (!copyer.Guard(this))
         {
             Monitor.Enter(guardLock);
             try
             {
                 if (guards.TryGetValue(copyer.ProcessId, out cache) && cache == copyer) guards.Remove(copyer.ProcessId);
             }
             finally { Monitor.Exit(guardLock); }
         }
         saveCache();
     }
 }
 private void copyStart(copyer copyer)
 {
     if (copyer.CheckName())
     {
         bool isGuard;
         Monitor.Enter(guardLock);
         try
         {
             isGuard = guards.Remove(copyer.ProcessId);
         }
         finally { Monitor.Exit(guardLock); }
         if (isGuard) saveCache();
         log.Default.Add("启动文件复制 " + copyer.Process, false, false);
         copyer.Copy();
     }
 }