コード例 #1
0
ファイル: GameUtil.cs プロジェクト: wooddice/PKHeX
 /// <summary>
 /// Gets the Generation the <see cref="GameVersion"/> belongs to.
 /// </summary>
 /// <param name="game">Game to retrieve the generation for</param>
 /// <returns>Generation ID</returns>
 public static int GetGeneration(this GameVersion game)
 {
     if (Gen1.Contains(game))
     {
         return(1);
     }
     if (Gen2.Contains(game))
     {
         return(2);
     }
     if (Gen3.Contains(game))
     {
         return(3);
     }
     if (Gen4.Contains(game))
     {
         return(4);
     }
     if (Gen5.Contains(game))
     {
         return(5);
     }
     if (Gen6.Contains(game))
     {
         return(6);
     }
     if (Gen7.Contains(game))
     {
         return(7);
     }
     return(-1);
 }
コード例 #2
0
ファイル: Gen.cs プロジェクト: jonaRdrgz/Proyecto_IA_2
        public void CalculateFitness()
        {
            double n       = Gen1.Count;
            double average = 0;

            foreach (Agent agent in Gen1.AsEnumerable())
            {
                average += agent.EarnedCommission;
            }

            average /= n; // promedio

            double variance = 0;

            foreach (Agent agent in Gen1.AsEnumerable())
            {
                double tmp = agent.EarnedCommission - average;
                variance += Math.Pow(tmp, 2); // (value, power)
            }

            variance /= n;

            double standardDeviation = Math.Sqrt(variance);      // si la desviacion estandar es cercana a cero los pagos son casi homogeneos.

            this.Fitness = standardDeviation + PenaltyFitness(); //Para poder saber si esta bien. // tener en cuenta el work time de cada agente.
        }
コード例 #3
0
        public static void Run()
        {
            Gen1 <object[]>[] g1 = new Gen1 <object[]> [1];
            g1[0] = new Gen1 <object[]>(new object[] { new object[1] });

            Gen1 <object[][]> g2 = new Gen1 <object[][]>(new object[1][]);
        }
コード例 #4
0
ファイル: Gen.cs プロジェクト: jonaRdrgz/Proyecto_IA_2
        public void Mutation(List <RequestedService> pRequestedServiceList)
        {
            int lengthGen = Gen1.Count;

            for (int i = 0; i < lengthGen; i++)
            {
                if (random.Next(100) <= MutationProbability)
                {
                    Service service = GetServiceValues(pRequestedServiceList.ElementAt(i).ServiceCode);

                    Agent agentToReplace = Gen1.ElementAt(i);
                    Agent newAgent       = AgentesByServiceDictionary[service.Code].ElementAt(random.Next(AgentesByServiceDictionary[service.Code].Count));

                    agentToReplace.JobCounter       -= 1;
                    agentToReplace.WorkTime         -= service.Time;
                    agentToReplace.EarnedCommission -= service.Commission;
                    agentToReplace.IsBusy            = agentToReplace.JobCounter == 0 ? false : true;

                    newAgent.JobCounter       += 1;
                    newAgent.WorkTime         += service.Time;
                    newAgent.EarnedCommission += service.Commission;
                    newAgent.IsBusy            = true;

                    Gen1[i] = newAgent;
                }
            }
        }
コード例 #5
0
ファイル: Gen.cs プロジェクト: jonaRdrgz/Proyecto_IA_2
        //mutacion por si algún agente queda sin trabajito :(
        public void ManipulatedMutation(List <RequestedService> pRequestedServiceList)
        {
            List <Agent> agentIsNotBusy = (from agent in AgentList
                                           where agent.JobCounter < 1
                                           select agent).ToList();

            foreach (Agent agent in agentIsNotBusy.AsEnumerable())
            {
                Agent agentToReplace = (from ag in Gen1
                                        where ag.ServiceList.Intersect(agent.ServiceList).Any() && ag.JobCounter > 1
                                        select ag).OrderByDescending(x => x.JobCounter).FirstOrDefault();

                for (int i = 0; i < pRequestedServiceList.Count; i++)
                {
                    if (Gen1.ElementAt(i).ID == agentToReplace.ID && agent.ServiceList.Contains(pRequestedServiceList.ElementAt(i).ServiceCode))
                    {
                        Service service = GetServiceValues(pRequestedServiceList.ElementAt(i).ServiceCode);

                        agentToReplace.JobCounter       -= 1;
                        agentToReplace.WorkTime         -= service.Time;
                        agentToReplace.EarnedCommission -= service.Commission;
                        agentToReplace.IsBusy            = agentToReplace.JobCounter == 0 ? false : true;

                        agent.JobCounter       += 1;
                        agent.WorkTime         += service.Time;
                        agent.EarnedCommission += service.Commission;
                        agent.IsBusy            = true;

                        //Swap
                        Gen1[i] = agent;
                    }
                }
            }
        }
コード例 #6
0
    public static void goGen1()
    {
        Gen1 <int> gen1 = new Gen1 <int>();

        gen1.t = 5;

        Console.WriteLine("Gen1: FAIL");
    }
コード例 #7
0
ファイル: Gen.cs プロジェクト: jonaRdrgz/Proyecto_IA_2
        public override string ToString()
        {
            string toString = "\n\nFitness: " + Fitness + "\n";

            foreach (Agent agent in Gen1.AsEnumerable())
            {
                toString += agent;
            }
            return(toString);
        }
コード例 #8
0
ファイル: GameUtil.cs プロジェクト: wooddice/PKHeX
 /// <summary>
 /// Gets the Generation the <see cref="GameVersion"/> belongs to.
 /// </summary>
 /// <param name="game">Game to retrieve the generation for</param>
 /// <returns>Generation ID</returns>
 public static int GetMaxSpeciesID(this GameVersion game)
 {
     if (Gen1.Contains(game))
     {
         return(Legal.MaxSpeciesID_1);
     }
     if (Gen2.Contains(game))
     {
         return(Legal.MaxSpeciesID_2);
     }
     if (Gen3.Contains(game))
     {
         return(Legal.MaxSpeciesID_3);
     }
     if (Gen4.Contains(game))
     {
         return(Legal.MaxSpeciesID_4);
     }
     if (Gen5.Contains(game))
     {
         return(Legal.MaxSpeciesID_5);
     }
     if (Gen6.Contains(game))
     {
         return(Legal.MaxSpeciesID_6);
     }
     if (Gen7.Contains(game))
     {
         if (SM.Contains(game))
         {
             return(Legal.MaxSpeciesID_7);
         }
         if (USUM.Contains(game))
         {
             return(Legal.MaxSpeciesID_7_USUM);
         }
         if (GG.Contains(game))
         {
             return(Legal.MaxSpeciesID_7b);
         }
         return(Legal.MaxSpeciesID_7_USUM);
     }
     return(-1);
 }
コード例 #9
0
ファイル: GameUtil.cs プロジェクト: wooddice/pkNX
 /// <summary>
 /// Gets the Generation the <see cref="GameVersion"/> belongs to.
 /// </summary>
 /// <param name="game">Game to retrieve the generation for</param>
 /// <returns>Generation ID</returns>
 public static int GetMaxSpeciesID(this GameVersion game)
 {
     if (Gen1.Contains(game))
     {
         return(151);
     }
     if (Gen2.Contains(game))
     {
         return(251);
     }
     if (Gen3.Contains(game))
     {
         return(384);
     }
     if (Gen4.Contains(game))
     {
         return(493);
     }
     if (Gen5.Contains(game))
     {
         return(649);
     }
     if (Gen6.Contains(game))
     {
         return(Legal.MaxSpeciesID_6);
     }
     if (Gen7.Contains(game))
     {
         if (SM.Contains(game))
         {
             return(802);
         }
         if (USUM.Contains(game))
         {
             return(807);
         }
         return(Legal.MaxSpeciesID_7_GG);
     }
     return(-1);
 }
コード例 #10
0
 public static string GetFromMethodParam()
 {
     return((Gen1 <T> .Get2 <T>() as T) as string);
 }
コード例 #11
0
 public static string GetFromClassParam()
 {
     return((Gen1 <T> .Get1() as T) as string);
 }
コード例 #12
0
ファイル: Gen.cs プロジェクト: jtrindade/isel-ave-1516-2
 public static void Main()
 {
     Gen1.Example();
     Gen2.Example();
 }
コード例 #13
0
        public void CreateDifferentPartial()
        {
            var _ = AbstractCallable._;

            Helper.RunWithMultipleSimulators((s) =>
            {
                {
                    var gen     = new GenericCallable(s, typeof(Gen1 <,>));
                    var partial = gen.Partial(_);
                    Assert.Equal(typeof(GenericPartial), partial.GetType());
                }

                {
                    var closed  = new Gen1 <long, bool>(s);
                    var partial = closed.Partial <ICallable>(_);
                    Assert.Equal(typeof(OperationPartial <(long, bool), (long, bool), bool>), partial.GetType());
                }

                {
                    var closed  = new Gen1 <(long, long), bool>(s);
                    var partial = closed.Partial <ICallable>(((3L, _), true));
                    Assert.Equal(typeof(OperationPartial <long, ((long, long), bool), bool>), partial.GetType());
                }

                {
                    var x       = s.Get <IUnitary <Qubit>, Intrinsic.X>();
                    var closed  = new Gen1 <(long, (IUnitary, Qubit, Result)), bool>(s);
                    var partial = closed.Partial <ICallable>(((_, (x, _, _)), true));
                    Assert.Equal(typeof(OperationPartial <(long, (Qubit, Result)), ((long, (IUnitary, Qubit, Result)), bool), bool>), partial.GetType());
                }

                {
                    var x       = s.Get <IUnitary <Qubit>, Intrinsic.X>();
                    var closed  = new Gen1 <(long, (IUnitary, Qubit, Result)), bool>(s) as ICallable <((long, (IUnitary, Qubit, Result)), bool), bool>;
                    var partial = closed.Partial(((_, (x, _, _)), false));
                    Assert.Equal(typeof(OperationPartial <(long, (Qubit, Result)), ((long, (IUnitary, Qubit, Result)), bool), bool>), partial.GetType());
                }

                {
                    var closed  = new Gen2 <(long, bool, Result), IUnitary>(s);
                    var partial = closed.Partial <IAdjointable>(((_, true, _), 3L, _));
                    Assert.Equal(typeof(OperationPartial <((long, Result), IUnitary), ((long, bool, Result), long, IUnitary), QVoid>), partial.GetType());
                }

                {
                    var closed  = new Gen2 <bool, Result>(s) as IAdjointable <(bool, long, Result)>;
                    var partial = closed.Partial((_, 3L, Result.Zero));
                    Assert.Equal(typeof(OperationPartial <bool, (bool, long, Result), QVoid>), partial.GetType());
                }

                {
                    var closed  = new Gen4 <bool, bool>(s) as IUnitary <(Result, (bool, bool), Result)>;
                    var partial = closed.Controlled.Partial((_, (_, (true, _), Result.Zero)));
                    Assert.Equal(typeof(OperationPartial <(IQArray <Qubit>, (Result, bool)), (IQArray <Qubit>, (Result, (bool, bool), Result)), QVoid>), partial.GetType());
                }

                {
                    var closed  = new Gen4 <bool, bool>(s) as IControllable <(Result, (bool, bool), Result)>;
                    var partial = closed.Controlled.Partial((_, (_, (true, _), Result.Zero)));
                    Assert.Equal(typeof(OperationPartial <(IQArray <Qubit>, (Result, bool)), (IQArray <Qubit>, (Result, (bool, bool), Result)), QVoid>), partial.GetType());
                }

                {
                    var closed  = new Gen2 <bool, Result>(s) as IAdjointable;
                    var partial = closed.Partial((_, 3L, Result.Zero));
                    Assert.Equal(typeof(OperationPartial <bool, (bool, long, Result), QVoid>), partial.GetType());
                }

                {
                    var closed  = new Gen4 <bool, bool>(s) as IUnitary;
                    var partial = closed.Adjoint.Controlled.Partial((_, (_, (true, _), Result.Zero)));
                    Assert.Equal(typeof(OperationPartial <(IQArray <Qubit>, (Result, bool)), (IQArray <Qubit>, (Result, (bool, bool), Result)), QVoid>), partial.GetType());
                }

                {
                    var closed  = new Gen4 <bool, bool>(s) as IControllable;
                    var partial = closed.Controlled.Partial((_, (_, (true, _), Result.Zero)));
                    Assert.Equal(typeof(OperationPartial <(IQArray <Qubit>, (Result, bool)), (IQArray <Qubit>, (Result, (bool, bool), Result)), QVoid>), partial.GetType());
                }
            });
        }
コード例 #14
0
 public static T1 GetDefault <T, T1>(this Gen1 obj, T1 param) where T : ConstructorStaticClass where T1 : Task
 {
     return(default(T1));
 }
コード例 #15
0
ファイル: Program.cs プロジェクト: returnres/exam
        static void Main(string[] args)
        {
            testa te = new testa();

            te.faccio(3);

            #region opertori
            PippoTest pippoTest  = new PippoTest(1);
            PippoTest pippoTest1 = new PippoTest(2);
            PippoTest pippoTest2 = new PippoTest(2);
            //implicit
            int testt = pippoTest2;
            //explicit
            PippoTest testtt = (PippoTest)3;

            //somma tra pippotest
            var rrrr = pippoTest1 + pippoTest;
            var ssss = pippoTest2++;

            //somma tra int e pippotest
            var ressss = 3 + testtt;
            #endregion

            #region TraceSource

            /*
             * LISTNER
             *
             * ConsoleTraceListener	Standard output or error stream
             * DelimitedListTraceListener	TextWriter
             * EventLogTraceListener	EventLog
             * EventSchemaTraceListener	XML-encoded, schema-compliant log file
             * TextWriterTraceListener	TextWriter
             * XmlWriterTraceListener	XML-encoded data to a TextWriter or stream.
             */
            //configuro da codice
            Stream outfile = File.Create("log.txt");
            //creo listner
            TextWriterTraceListener textWriterTraceListener = new TextWriterTraceListener(outfile);
            TraceSource             traceSource             = new TraceSource("myT", SourceLevels.All);

            //cancello quello di default
            traceSource.Listeners.Clear();
            //aggiungo mio
            traceSource.Listeners.Add(textWriterTraceListener);

            traceSource.TraceInformation("");
            traceSource.TraceEvent(TraceEventType.Critical, 0, "");
            traceSource.TraceData(TraceEventType.Information, 1, "");
            traceSource.Flush();
            traceSource.Close();

            //TraceSource configuro da appsetting
            mySource.TraceEvent(TraceEventType.Error, 1,
                                "Error message.");
            mySource.TraceEvent(TraceEventType.Warning, 2,
                                "Warning message.");

            #endregion

            #region BooleanSwitch
            var sw = new System.Diagnostics.BooleanSwitch("QueryLogger", "QueryLogger");
            if (sw.Enabled)
            {
                Console.WriteLine("Booleanswitchenabled");
            }
            #endregion

            #region TraceSwitch

            /*
             * SourceSwitch e TraceSwitch sono altri due tipi di switch che servono a controllare
             * la verbosità del trace e la “sorgente” del trace.
             * Ovvero, se usi il tracing in maniera seria puoi, grazie al SourceSwitch,
             * definire varie sorgenti di tracing e regolarle a tua discrezione con il TraceSwitch.
             */
            ////Define this in the web config
            TraceSwitch generalSwitch = new TraceSwitch("General",
                                                        "Entire Application");

            string msgText = "1";

            // Write INFO type message, if switch is set to Verbose, type 4
            Trace.WriteIf(generalSwitch.TraceVerbose, msgText);

            msgText = "A2MC";

            // Write INFO type message, if switch is set to Verbose or Warning 4 0r 2
            Trace.WriteIf(generalSwitch.TraceWarning, msgText);

            // Write ERROR type message, if switch is set to Verbose, Warning, info or Error
            // 0 (off), 1 (error), 2 (warning), 3 (info), OR 4 (verbose)
            //If General switch in WEB CONFIG = 0 then it will not get into the if below
            if (generalSwitch.TraceError)
            {
                //Trace type, inthis case error will define how it will appear in the event log
                Trace.TraceError("Error");
                //Use your imagination to switch it on and off properly.
                //You can really imagine and apply.
            }
            #endregion

            #region EventLog
            if (!EventLog.SourceExists("Mysource"))
            {
                EventLog.CreateEventSource("MySource", "MyLog");
            }

            EventLog eventLog = new EventLog();
            eventLog.Source = "MySource";
            eventLog.WriteEntry("Ciao J0n");
            #endregion

            #region PerformanceCounter

            /* CounterCreationDataCollection
             * CounterCreationData (PerformanceCounterType)
             * PerformanceCounterCategory (si prende il collection che si prende il data) (PerformanceCounterCategoryType)
             * PerformanceCounter
             */

            var performanceCounterCategories = PerformanceCounterCategory.GetCategories();
            var first = performanceCounterCategories.FirstOrDefault(category => category.CategoryName == "Processor");

            var performanceCounters = first.GetCounters("_Total");

            Console.WriteLine("Displaying performance counters for Processor category:--\n");

            foreach (PerformanceCounter performanceCounter in performanceCounters)
            {
                Console.WriteLine(performanceCounter.CounterName);
            }

            //v2custom
            String customCategoryName = "Custom Performance Counter Category";
            string counterNameCustom  = "pippo";
            if (!PerformanceCounterCategory.Exists(customCategoryName))
            {
                CounterCreationDataCollection counterCreationDataCollection = new CounterCreationDataCollection();
                counterCreationDataCollection.Add(new CounterCreationData(counterNameCustom, "Sample Counter 1", PerformanceCounterType.ElapsedTime));
                //counterCreationDataCollection.Add(new CounterCreationData("Counter 2", "Sample Counter 2", PerformanceCounterType.SampleCounter));
                PerformanceCounterCategory.Create(customCategoryName, "This is just an example", PerformanceCounterCategoryType.SingleInstance, counterCreationDataCollection);
                var counter = new PerformanceCounter(customCategoryName, counterNameCustom, false);
                counter.Increment();
            }
            using (var counter = new PerformanceCounter(customCategoryName, counterNameCustom, false))
            {
                counter.Increment();
            }

            //v2custom
            string counterName  = "countername";
            string categoryName = "categoryname";
            if (!PerformanceCounterCategory.Exists("categoryname"))
            {
                CounterCreationDataCollection datacollection = new CounterCreationDataCollection();

                CounterCreationData numberOfItems = new CounterCreationData();
                numberOfItems.CounterType = PerformanceCounterType.NumberOfItems32;
                numberOfItems.CounterName = counterName;
                datacollection.Add(numberOfItems);

                // Create the category.
                PerformanceCounterCategory.Create(categoryName,
                                                  "Demonstrates usage of the AverageTimer32 performance counter type",
                                                  PerformanceCounterCategoryType.SingleInstance, datacollection);

                var counter = new PerformanceCounter(categoryName, counterName, false);

                counter.RawValue = 0;
                counter.Increment();
            }
            using (var counter = new PerformanceCounter(categoryName, counterName, false))
            {
                counter.Increment();
            }
            #endregion

            #region  OOP
            MyMethodCond();

            string main = "Main";
            Trace.Write("trace");
            Debug.Write("debug");
            Debug.Assert(main == "Main");

            Ciccio c = new Ciccio();
            c.Prova();
            ICiccio s = (ICiccio)c;
            s.Prova();
            ICiccio1 s1 = (ICiccio1)c;
            s1.Prova();
            c.Nano();

            double xxx = 0.0;
            double yyy = 0.0;
            //var reszzzz = xxx / yyy;NAN
            IIbabbo babbo11 = new Figliolo();
            babbo11.MioMetodo();

            Mio("ciao");
            Mio("ciao", paperino: 1);
            Mio("ciao", pluto: true, paperino: 1);
            //Mio("ciao",pluto:false,1);ERRORE
            //Pippo pippos = new Pippo();
            //pippos.DoSOmething();

            #endregion

            #region  GENERZIONE DINAMICA CODICE

            /*
             *
             * //System.Reflection.Emit
             * //creazione , lancio e salvataggoi IL a runtime
             * AssemblyName nameAss = new AssemblyName("DynamicAss");
             * AssemblyBuilder assemblyBuilder =
             *  AppDomain.CurrentDomain.DefineDynamicAssembly(nameAss, AssemblyBuilderAccess.RunAndSave);
             * ModuleBuilder moduleBuilder = assemblyBuilder.DefineDynamicModule("DynamicMod", "DynamicAss.dll");
             * //classe
             * TypeBuilder tb = moduleBuilder.DefineType("HelloClass", TypeAttributes.Class | TypeAttributes.Public);
             * //metodo
             * MethodBuilder mb =
             *  tb.DefineMethod("PrintHello", MethodAttributes.Public, null, new Type[] { typeof(string) });
             * ILGenerator myGenerator = mb.GetILGenerator();
             * myGenerator.Emit(OpCodes.Ldstr, "Hello");
             * myGenerator.Emit(OpCodes.Ldarg_1);
             * MethodInfo concatMetod = typeof(String).GetMethod("Concat", new Type[] { typeof(string), typeof(string) });
             * myGenerator.Emit(OpCodes.Call, concatMetod);
             * MethodInfo wrMethodInfo = typeof(Console).GetMethod("Write", new Type[] { typeof(string) });
             * myGenerator.Emit(OpCodes.Call, wrMethodInfo);
             * myGenerator.Emit(OpCodes.Ret);
             *
             * //istanzio ogetto
             * Type helloType = tb.CreateType();
             * object helloobj = Activator.CreateInstance(helloType);
             * MethodInfo hellMethodInfo = helloType.GetMethod("PrintHello", new[] { typeof(string) });
             *
             * //invoco metodo passando parametro
             * hellMethodInfo.Invoke(helloobj, new object[] { "J0n" });
             *
             * //salvo dll
             * assemblyBuilder.Save("DynamicAss.dll");
             #endregion
             *
             * HelloClass  helloClass = new HelloClass();
             * helloClass.PrintHello("ciao");
             */


            //System.CodeDom
            //creare  salvare e compilare  codice sorgente e runtime
            CodeCompileUnit codeCompileUnit = new CodeCompileUnit();
            CodeNamespace   codeNamespace   = new CodeNamespace("CodeDOM");
            codeNamespace.Imports.Add(new CodeNamespaceImport("System"));
            //classe
            CodeTypeDeclaration myclass = new CodeTypeDeclaration("Pippo");

            //metodo
            CodeMemberMethod codeMemberMethod = new CodeMemberMethod();
            codeMemberMethod.Name       = "DoSOmething";
            codeMemberMethod.Attributes = MemberAttributes.Public;
            CodeMethodInvokeExpression codeMethodInvokeExpression = new CodeMethodInvokeExpression(
                new CodeTypeReferenceExpression("Console"), "WriteLine", new CodePrimitiveExpression("Ciao Ciccio"));
            CodeMethodInvokeExpression codeMethodInvokeExpression1 = new CodeMethodInvokeExpression(
                new CodeTypeReferenceExpression("Console"), "ReadLine");
            codeCompileUnit.Namespaces.Add(codeNamespace);
            codeNamespace.Types.Add(myclass);
            myclass.Members.Add(codeMemberMethod);
            codeMemberMethod.Statements.Add(codeMethodInvokeExpression);
            codeMemberMethod.Statements.Add(codeMethodInvokeExpression1);

            //salva codice sorgente
            CSharpCodeProvider provider = new CSharpCodeProvider();

            string pathSource = @"../../bin/Debug/Pippo.cs";
            string pathOut    = @"../../bin/Debug/Pippos.dll";

            //string pathSource = @"../../autogenerated/Pippo.cs";
            //string pathOut = @"../../autogenerated/Pippos.exe";
            using (StreamWriter stream = new StreamWriter(pathSource, false))
            {
                IndentedTextWriter tw = new IndentedTextWriter(stream, "   ");
                provider.GenerateCodeFromCompileUnit(codeCompileUnit, tw, new CodeGeneratorOptions());
                tw.Close();
            }

            CompileCSharpCode(pathSource, pathOut);

            #endregion

            #region reflection
            //REFLECTION System.Assembly
            //assembly (IL codice compilato) exe/dll
            //carico in memoria assembly

            //PLUGIN
            //caricamento dinamico  assembly da path
            Assembly assm = Assembly.LoadFrom(@"C:\Users\rob\source\repos\Exam\Plugin1\bin\Debug\Plugin1.dll");
            Type[]   tips = assm.GetTypes();
            foreach (var item in tips)
            {
                //var objectType = Type.GetType(objectToInstantiate);
                Type objectType         = assm.GetType(item.FullName);
                var  instantiatedObject = Activator.CreateInstance(objectType);
            }
            //carica solo metadati dei tipi SENZA instanziare i tipi
            Assembly ass2 = Assembly.ReflectionOnlyLoadFrom("ClassLibrary1.dll");

            //var instantiatedObject1 = Activator.CreateInstance(typeof(Tipo));
            //var instantiatedObject2 = Activator.CreateInstance<Tipo>;
            string sss = new String(new char[3]);
            //assembly attualmente in esecuzione
            Assembly ass             = Assembly.GetExecutingAssembly();
            Assembly ass1            = Assembly.GetAssembly(typeof(string));
            Assembly ass12           = Assembly.GetAssembly(sss.GetType());
            var      mytype          = ass.GetType("ConsoleApp1.Program");
            var      fullname        = ass.FullName;
            var      nome            = mytype.Name;
            var      mytypeNamespace = mytype.Namespace;

            var typeinfo = typeof(MiaclasseProva).GetTypeInfo();
            var name     = typeinfo.FullName;

            //ottengo tipo classe
            MiaclasseProva miaclasseProva = new MiaclasseProva();

            var typeinfo1 = miaclasseProva.GetType().GetTypeInfo();

            //ottengo interafccia
            var interfaccie = typeinfo1.GetInterfaces();

            //ottengo metodi e parametri
            MethodInfo[] metodi = typeinfo1.GetMethods(BindingFlags.Instance);
            foreach (var metodo in metodi)
            {
                var pi = metodo.GetParameters();
                foreach (var parinfo in pi)
                {
                    Console.WriteLine($" parametro : {parinfo.ParameterType.Name}");
                }
            }

            //ottengo membri
            MemberInfo[] membri = typeinfo1.GetMembers(BindingFlags.Public | BindingFlags.NonPublic);
            foreach (var mambro in membri)
            {
                var mi = mambro.MemberType;
            }
            #endregion

            #region IComparable
            //confrontare oggetti
            ComparableMoto comparableMoto = new ComparableMoto();
            comparableMoto.Targa = "pippo";
            ComparableMoto comparableMoto1 = new ComparableMoto();
            comparableMoto1.Targa = "pluto";

            int ord = comparableMoto.CompareTo(comparableMoto1);

            List <ComparableMoto> comparableMotos = new List <ComparableMoto>();
            comparableMotos.Add(new ComparableMoto()
            {
                Targa = "A"
            });
            comparableMotos.Add(new ComparableMoto()
            {
                Targa = "B"
            });
            comparableMotos.Add(new ComparableMoto()
            {
                Targa = "C"
            });
            comparableMotos.Sort();

            //AppDomain.CurrentDomain.UnhandledException += OnUnhandleException;
            //ManageException manage = new ManageException();
            //manage.GeneroEccezioneNonGestita();
            #endregion

            #region ref out static class
            Figlio   figlio1  = new Figlio();
            Figlio   figlio   = new Figlio("as");
            Macchina macchina = new Macchina("320", "bmw");
            macchina.Parti();
            SmartPhone.Battery     battery = new SmartPhone.Battery();
            ConstructorStaticClass constructorStaticClass = new ConstructorStaticClass();
            ConstructorStaticClass miaclasse2             = new ConstructorStaticClass();
            Console.WriteLine(ConstructorStaticClass.contatore);
            ClassTest1 babbo   = new ClassTest1();
            var        testref = 0;
            double     resp2;
            double     resp3;

            //ref
            babbo.cambiaNumero(ref testref);
            //out scarta valore resp3
            babbo.potenza(2, out resp2, out _);
            var media = babbo.CalcolaMedia(18, 27, 27, 27);
            babbo.ParametriNome(nome: "rob", anni: 43);

            //c#7
            //double xresp2;
            //double xresp3;
            //babbo.potenza1(2,  xresp2,  xresp3);

            int x1 = 0;
            //block
            if (x1 == 0)//expression
            {
                //codice
            }

            int?    nullable = null;
            var     cliente  = new { nome = "rob" };
            Mesi    giorno   = Mesi.febbraio;
            int     mese     = (int)Mesi.febbraio;
            Mesi    mese1    = (Mesi)1;
            Pippolo pippo;
            pippo.a = 1;


            #endregion

            #region cast box unbox
            //cast
            int     i     = 123;
            object  box   = i;
            int     n     = (int)box;//unbox
            dynamic dd    = 1;
            int     inc   = dd + 1;
            var     ssss1 = Convert.ToString(1);
            dynamic dy    = new ExpandoObject();
            #endregion

            #region type

            //OTTENGO IL TIPO
            //GetType
            var  ti = typeof(string).GetTypeInfo();
            Type ts = Type.GetType("System.String");//se si trova in Mscorelib.dll

            TestClass tc   = new TestClass();
            Type      tipo = tc.GetType();

            //typeof
            Type type = typeof(Type);

            //CONTROLLO IL TIPO
            //is tipo | as tipo
            string obj = "";
            if (obj is string)
            {
                //cast ()
                string a  = (string)obj;   //se obj non è compatibile con string cast exception
                string a1 = obj as string; //se obj non compatobole con string ritorna null
            }


            #endregion

            #region array
            Console.WriteLine($"metodo {nameof(Main)}");

            /*
             * stack => vet
             * heap 1
             * heap 2
             * heap 3
             *
             * ARRAY MULTID:
             * -array rettangoli
             * 1234
             * 1234
             *
             * -array jagged (irregolare)
             * 123456
             * 234
             * 2343434343
             */

            //array
            int[] vet = new[] { 1, 2, 3 };

            //array regolari matrici
            int[,] matrix = new int[3, 4];
            matrix[0, 0]  = 1;

            int[,] matrix1 =
            {
                { 1, 2, 3, 4 },
                { 5, 6, 7, 8 }
            };

            //jagged array irregolari
            int[][] jagged = new int[3][];
            jagged[0] = new int[2] {
                1, 2
            };
            jagged[1] = new int[4] {
                1, 2, 3, 4
            };
            #endregion

            #region c7 PATTERN MATCHING

            /*
             * type => espr is tipo v
             * const => espr is constante
             * var
             *
             * */

            //type
            object obj1 = "";
            if (obj1 is string str)
            {
                Console.WriteLine(str);
            }

            //invece che

            if (obj1 is string)
            {
                string str1 = (string)obj;
                Console.WriteLine(str1);
            }

            //const
            Mesi giornomese = Mesi.febbraio;
            bool feb        = giornomese is Mesi.febbraio;//true se giorno di febbraio

            #endregion

            #region  Event
            //Event
            Pub pub = new Pub();
            //mi iscrivo e gli dico di fare questo quando viene sollevato evento evento
            pub.OnChange += () => Console.WriteLine("lambda");
            pub.OnChange += delegate { Console.WriteLine("delegate"); };

            //sollevo evento
            pub.Raise();

            Pub1 p1 = new Pub1();
            p1.OnChange += () => Console.WriteLine("lambda");
            p1.Raise();

            Pub2 p2 = new Pub2();
            p2.CreateAndRaise();

            Car        car = new Car();
            CarMonitor cm  = new CarMonitor(car);

            car.Decelerate();

            #endregion

            #region Expression Tree
            //Expression Tree
            Expression <Func <int, bool> > exp1 = x => x % 2 == 0;
            Func <int, bool> isPari             = exp1.Compile();//dopo che l'ho compliat posso eseguirla, prima era solo un albero di espressopmo
            if (isPari(4))
            {
                Console.WriteLine("pari");
            }
            #endregion

            #region delegate

            //assegno lambda (anonyous method)
            myDelegate myd = (x) => 1;
            Console.WriteLine(myd("0ciao"));

            //assegno metodo
            myDelegate myd1 = MethodForDel;
            Console.WriteLine(myd1("1ciao"));

            //assegno delegate
            myDelegate myd2 = delegate { return(1); };
            Console.WriteLine(myd2("2ciao"));
            #endregion

            #region VARIANZA
            //COVARIANZA OUT
            //ti faccio assegnare sia metodo che ritorna stringa
            //ma anche metodo che torna object perchè stringa deriva
            //da object (è piu specifica)
            Del          d1   = new Del();
            Cov <string> cov  = d1.Cov1;
            Cov <object> cov1 = d1.Cov2;
            Cov <object> cov3 = d1.Cov2;
            //Cov<string> cov2 = d1.Cov2;//no object non deriva da stringa

            //CONTROVARIANZA IN
            //ti faccio assegnare sia metodo che prende ingresso
            //classe piu generica object  ma ache classe piu specifica string
            Con <object> con  = d1.Con1;
            Con <string> con3 = d1.Con1;
            Con <string> con1 = d1.Con2;
            //Con<object> con2 = d1.Con2;//no

            var res3 = d1.MyCon(Convert.ToInt32, "5");
            var res4 = d1.MyCon1(Convert.ToInt32, "5");
            var res5 = d1.MyConGen(Convert.ToInt32, "5");
            var res6 = d1.MyConGen(Convert.ToBoolean, 0);
            var res7 = d1.MyConGen(Convert.ToString, 5);
            Console.WriteLine(res3);
            Console.WriteLine(res4);

            d1.UseMulticast();

            #endregion

            #region generics
            Task tx1 = Task.Run(() =>
            {
                Console.WriteLine("ciao");
            });
            Task[] tasksarr = new Task[1];
            tasksarr[0] = tx1;

            Gen1 gen1 = new Gen1();

            if (gen1.GetDefault <ConstructorStaticClass, Task>(tx1) != null)
            {
                gen1.ContinueTaskOrDefault(tx1, Console.WriteLine);
                Console.WriteLine("start task generic");
            }

            var mytaskList = gen1.ContinueTasksOrDefault(tasksarr, Console.WriteLine);


            if (mytaskList != null)
            {
                Console.WriteLine("starts tasks generic");
            }


            Gen2 <Constructor>             gen2       = new Gen2 <Constructor>();
            Gen2Figlia <Constructor>       gen2figlia = new Gen2Figlia <Constructor>();
            Gen1Figlia <Constructor, Task> tesFiglia  = new Gen1Figlia <Constructor, Task>();

            //variabile statico è diverso per tipo
            TestStaticGen <string> .Status = "rob";
            TestStaticGen <int> .Status    = 1;
            Console.WriteLine(TestStaticGen <string> .Status);
            Console.WriteLine(TestStaticGen <int> .Status);

            TestStatic.Status = "ciao";
            TestStatic.Status = "ciau";
            Console.WriteLine(TestStatic.Status);
            //

            Generica <string, int, DateTime, bool> gen = new Generica <string, int, DateTime, bool>();


            List <Lista <string> > genericiInnestati = new List <Lista <string> >();
            genericiInnestati.Add(new Lista <string>(5));
            genericiInnestati[0][0] = "ciao";
            genericiInnestati[0][1] = "come ";
            genericiInnestati[0][2] = "stai";
            genericiInnestati[0][3] = "rob";
            genericiInnestati[0][4] = "?";

            foreach (var item in genericiInnestati)
            {
                for (int j = 0; j < 5; j++)
                {
                    Console.WriteLine(item[j]);
                }
            }

            Lista <string> lista = new Lista <string>(5);
            lista[0] = "";
            #endregion

            #region programmazione parallela
            //PLINQ solo linq to onject NO linq to sql
            //prende base dati la divide in segmenti e fa query in parallelo su questi segmentie  pio unisce iriaultati
            // se i lavori nonn sono complessi e la base dati è minima la programmazione parallela non da buoni risultati
            var qy = from num in Enumerable.Range(1, 8).AsParallel()
                     select Math.Pow(2, num);

            //stampa da 1 a 9 (9 numeri NON in ordine)
            //iterazioni indipendenti l'una dall altra quindi per tutti e due ordine non è sequnziale
            Parallel.For(1, 10, g => Console.WriteLine("g-{0}", g));
            var result = Parallel.For(0, 50, (g, parallelLoopState) =>
            {
                if (g > 5)
                {
                    parallelLoopState.Break();
                }
            });

            if (!result.IsCompleted)
            {
                var o = result.LowestBreakIteration;
            }

            //non è sequnziale
            List <string> list = new List <string>()
            {
                "ciao", "come", "va?"
            };
            Parallel.ForEach(list, word => Console.WriteLine("{0}", word, word.Length));
            #endregion

            #region async await

            var res1 = DoCurlAsync();

            //net 4.5
            //await salva lo stato del contesto del caller e quando il metodo await si conclude
            //il contesto ritorna allo stato del chimante che puo eseguire il codice successivo
            //questo nel caso di ui permette di modiicare la ui che  proprieta nella app gui del thread
            //della ui e viene eseguito nel ui syncronization context (dispatchercontext nella ui)
            //DAL C#7 TUTTO PUO ESSERE AWAITABLE ED ESEGUITO AINCRONO E NON  SOLO ISTANZA DI TASK
            //QUALSIAIS OGGETTO CHE ESPONE METODO GETAWAITER INFATTI LA CLASSE TASK ESPONE METODO GETAWAITER
            //await non puo essere usato su unsafe, lock, main
            MetodoAsyn();
            Console.WriteLine("codice prima fine await)");

            Task <string> res = GetAsync();

            List <string> files = new List <string>()
            {
                "pippo.txt", "pippo1.txt"
            };
            files.ForEach(async file => await ReadFileAsync(file));

            //all block
            //.Wait()
            //.Result
            //.GetAwaiter()
            //.GetResult()

            #endregion

            #region task tpl

            //manca continuewhenall
            //continuewheany
            //task figli innestati

            //Task.WaitAll blocks the current thread until everything has completed.
            //Task.WhenAll returns a task which represents the action of waiting until everything has completed.
            //That means that from an async method, you can use:
            // A DIFFERENZA DI WAIT ALL TORNA SOLO LA PRIMA ECCEZIONE NON AGGREGATE
            Task[] tasksArray = new Task[3];
            tasksArray[0] = Task.Run(() => { Thread.Sleep(4000); });
            tasksArray[1] = Task.Run(() => { Thread.Sleep(4000); });
            tasksArray[2] = Task.Run(() => { Thread.Sleep(4000); });
            var ry = MyAsyncWhenAll(tasksArray);
            Console.WriteLine("tornato da MyAsyncWhenAll");


            Task tx = Task.Run(() =>
            {
                Thread.Sleep(1000);
            });
            Task ty = Task.Run(() =>
            {
                Thread.Sleep(1000);
            });

            Task taskall = Task.WhenAll((new Task[] { tx, ty }));

            //Task taskall = Task.WhenAny((new Task[] { t1, t2 }));
            taskall.Wait();

            Task <String> webtask = Task.Run(() =>
            {
                string url   = "http://www.google.it";
                WebClient wc = new WebClient();
                return(wc.DownloadString(url));
            });

            Task <String> headhtml = webtask.ContinueWith <string>(x =>
            {
                var res2 = x.Result;
                //fai qualcosa con res
                return(res2);
            });

            var tokenSource         = new CancellationTokenSource();
            CancellationToken token = tokenSource.Token;

            Task cancellabletask = null;
            try
            {
                cancellabletask = Task.Run(() =>
                {
                    token.ThrowIfCancellationRequested();
                    for (int d = 0; d < 2; d++)
                    {
                        Thread.Sleep(100);
                        if (token.IsCancellationRequested)
                        {
                            //eseguo altre cose
                            token.ThrowIfCancellationRequested();
                        }
                    }
                }, token);

                tokenSource.CancelAfter(1000);
                cancellabletask.Wait();
            }
            catch (AggregateException aggregateException)
            {
                if (aggregateException.InnerException is OperationCanceledException)
                {
                    Console.WriteLine("OperationCanceledException£");
                }
                if (cancellabletask != null && (cancellabletask.IsCanceled && cancellabletask.Status == TaskStatus.Canceled))
                {
                    Console.WriteLine(aggregateException.ToString());
                }
            }


            Task <String> task = Task.Run(() =>
            {
                string url   = "http://www.google.it";
                WebClient wc = new WebClient();
                return(wc.DownloadString(url));
            });
            var htmlUrl = task.Result;//blocco

            List <Task> tasks = new List <Task>();
            for (int r = 0; r < 5; r++)
            {
                int number = r;
                tasks.Add(
                    Task.Run(() =>
                {
                    Console.WriteLine(number);
                    Thread.Sleep(1000);
                }));
            }

            //Task.WaitAll(tasks.ToArray());
            Task.WaitAny(tasks.ToArray());
            Console.WriteLine("all task complete");

            Task longtask = Task.Run(() =>
            {
                Thread.Sleep(1000);
            });
            longtask.Wait(1000);


            Task verylong = Task.Factory.StartNew(() =>
            {
                Thread.Sleep(2000);
            }, TaskCreationOptions.LongRunning);
            #endregion tpl

            #region thread
            for (int w = 0; w < 5; w++)
            {
                ThreadPool.QueueUserWorkItem(LongOperation);
            }


            Thread threada = new Thread(IncrMon);
            Thread threadb = new Thread(IncrMon);
            threada.Start();
            threadb.Start();
            threada.Join();
            threadb.Join();
            Console.WriteLine("n={0}", n2);

            Thread thread1 = new Thread(Incr);
            Thread thread2 = new Thread(Incr);
            thread1.Start();
            thread2.Start();
            thread1.Join();
            thread2.Join();
            Console.WriteLine("n={0}", n1);

            Thread t = new Thread(() =>
            {
                Console.WriteLine(Thread.CurrentThread.Name);
                Thread.Sleep(1000);
            });

            Thread t1 = new Thread(() =>
            {
                Console.WriteLine(Thread.CurrentThread.Name);
                for (int z = 0; z < 10; z++)
                {
                    lock (lockobj)
                    {
                        n = n + 1;
                        Thread.Sleep(1);
                        Console.WriteLine("n={0}", n);
                    }
                }
            });
            Thread t2 = new Thread(() =>
            {
                Console.WriteLine(Thread.CurrentThread.Name);
                for (int x = 0; x < 10; x++)
                {
                    lock (lockobj)
                    {
                        n = n + 1;
                        Thread.Sleep(1);
                        Console.WriteLine("n={0}", n);
                    }
                }
            });

            t.IsBackground = true;                       //termina appena finisce la app
            t.Priority     = ThreadPriority.AboveNormal; //determinata quantita di cpu destinata al thread ma non è deterministico
            t.Start();
            t1.Start();
            t2.Start();
            t.Join();//il codice si blocca e attende che t finisce

            #endregion

            Console.ReadLine();
        }