Jump to content
IT-პროგრამირების ფორუმი
Sign in to follow this  
samuraisxmali

პრივატულ ცვლადთან წვდომა

Recommended Posts

სახელმძღვანელოებში ჩვეულებრივ წერია, რომ პრივატულ ცვლადებს ვერ გამოვიყენებთ და მის მნიშვნელობებს ვერ მივიღებთ იმ კლასის გარეთ რომელშიც ისაა გამოცხადებული (თუ რა თქმა უნდა არ გვაქვს მაგალითდ Public თვისება რომელიც ამ პრივატულ ცვლადს იყენებს). მაგრამ არსებობს ხერხი, რომლის საშუალებითაც ჩვენ შეგვიძლია მივიღოთ კონკრეტული ცვლადის მნიშვნელობა. ამის საშუალებას გვაძლევს სახელსივრცე System.Reflections;

კოდს რომლითაც შეგვიძლია პრივატული ცვლადის მნიშვნელობა მივიღოთ ასეთი სახე აქვს:

using System;
using System.Reflection;

namespace PrivateFields
{
    public class MyClass
    {
        private string paroli = "scripts";
    }


    class Program
    {
        static void Main(string[] args)
        {
            var myInstance = new MyClass();
            var fieldInfo = typeof(MyClass).GetField("paroli",
                                  BindingFlags.NonPublic | BindingFlags.Instance);
            var pass = fieldInfo.GetValue(myInstance);
            Console.WriteLine(pass);
            Console.ReadKey();
        }
    }
}

ხო და, მოკლედ, როცა ლექციაზე იქნებით და გეტყვიან იმას რაც ზემოთ დავწერე, ააფარეთ ეს კოდი :დ

  • Upvote 1

Share this post


Link to post
Share on other sites

ვაა საინტერესოა, მაგრამ კოდის წერისას რატო უნდა გამოიყენო ეს მეთოდი არ ვიცი... მაგრამ ეგ კაი აზრია რო იტყვიან private კლასს დახურულია გარე კლასებისთვისო უნდა შევაკამათო და წავა იქ ომი  :taunt:

Share this post


Link to post
Share on other sites

პრაქტიკულ გამოყენებას ვერც მე მივხვდი, მაგრამ ალბათ მეტისმეტად მაგარი ინკაფსულაციის საკითხია, რა ვიცი აბა. ყველა ვარიანტში მაგარია, ლექტორი რომ გეუბნება, პრივატული ცვლადი სხვა კლასებისთვის დახურულიაო და შენ რო ჩაილაპარაკებ მტ$#% შ#$$იო : )))))))))))))

  • Upvote 5

Share this post


Link to post
Share on other sites

რეფლექსიით ეს ნელა ხდება, ამ შემთხვევაში როცა პრივატული ცვლადის მნიშვნელობის მიღება გვინდა linq-ის გამოყენება ჯობია

Share this post


Link to post
Share on other sites

თაზო ბაღდავაძე, პრივატულ ცვლადს სხვა კლასიდან ლინქით ვერ მიიღებ. თანაც ლინქი ყველაზე ნელია მთელ ვიზუალ სტუდიოში.

Share this post


Link to post
Share on other sites

თაზო ბაღდავაძე, პრივატულ ცვლადს სხვა კლასიდან ლინქით ვერ მიიღებ. თანაც ლინქი ყველაზე ნელია მთელ ვიზუალ სტუდიოში.

 

linq-ით არა უფრო სწორედ Linq.Expressions შეგიძლია გამოიყენო და ეს რეფლექსიაზე სწრაფია მე როგორც ვიცი, აი კოდი:

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Linq;
using System.Linq.Expressions;

class MyClas2s
{
    static void Main(string[] args)
    {
        Klasi klasi = new Klasi();
        Console.WriteLine(Private_cvladis_migeba<Klasi, A>("cvladi")(klasi));
        Console.ReadLine();
    }
    public static Func<T, R> Private_cvladis_migeba<T, R>(string cvladis_saxeli)
    {
        ParameterExpression param = Expression.Parameter(typeof(T), "arg");

        MemberExpression member = Expression.Field(param, cvladis_saxeli);

        LambdaExpression lambda = Expression.Lambda(typeof(Func<T, R>), member, param);

        Func<T, R> compiled = (Func<T, R>)lambda.Compile();

        return compiled;
    }
}
    enum A
    {
        a, b, c
    }
public class Klasi
{
    A cvladi = A.b;
}

Share this post


Link to post
Share on other sites

თაზო ბაღდავაძე, ეგ რაღაც ვერ გავიგე და მოდი ჩემს მაგალითზე გააკეთე

public class MyClass
    {
        private string paroli = "scripts";
    }

ეს გამოიყენე შეუცვლელად და ეს პაროლი დააბრუნებინე. თუ დააბრუნებს მერე შევამოწმებ დროს.

Share this post


Link to post
Share on other sites

აი გადავაკეთე მაგის გამოყენებით, ადრე ვნახე ეს კოდი ვიღაცის ბლოგზე და იმას ჰქონდა მგონი გაზომილი დრო თუ სწორად მახსოვს

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Linq;
using System.Linq.Expressions;

class Program
{
    static void Main(string[] args)
    {
        MyClass mc = new MyClass();
        var migeba = Private_cvladis_migeba<MyClass, string>("paroli");   // gadavcemt klass, dasabrunebel tips da cvladis saxels
        string shedegi = migeba(mc);  // gadavcemt klasis obieqts
        Console.WriteLine(shedegi);
        Console.ReadLine();
    }
    public static Func<T, R> Private_cvladis_migeba<T, R>(string cvladis_saxeli)
    {
        ParameterExpression param = Expression.Parameter(typeof(T), "arg");

        MemberExpression member = Expression.Field(param, cvladis_saxeli);

        LambdaExpression lambda = Expression.Lambda(typeof(Func<T, R>), member, param);

        Func<T, R> compiled = (Func<T, R>)lambda.Compile();

        return compiled;
    }
}
public class MyClass {
    private string paroli = "scripts";
}

ხო მართალი ხარ, არასწორად მხსომებია, რეფლექსია უფრო სწრაფად მუშაობს ამ შემთხვევაში


მაგრამ ეს მხოლოდ იმ შემთხვევაში თუ ერთი ობიექტიდან გვჭირდება ცვლადი, linq expression-ის გამოყენებისას ლამბდას კომპილაციას მიაქვს დრო და თუ კი ბევრჯერ გვინდა ერთი და იგივე კლასის ობიექტებიდან ცვლადის მნიშვნელობის მიღება, ამ შემთხვევაში linq expression -ის გამოყენება 100-ჯერ და მეტჯერ სწრაფი იქნება

Share this post


Link to post
Share on other sites

sfr9zKM.png

 

 

ეს პირველი არის ლინქის მეთოდით. Intel Core i3 / 3.10GHz პროცესორზე 3.8-დან 6.7 მილიწამამდე ანდომებს ამ ცვლადის მნიშვნელობის დაბრუნებას. საშუალო დაახლოებით 5 მილიწამია.

 

 

yiOC9Kv.png

 

ეს მეორე კი არის ექსპრეშენების მეთოდით და ანდომებს 0.2 მილიწამიდან 0.36 მილიწამამდე. როგორც ჩანს ეს მეთოდი დაახლოებით 15-20-ჯერ უფრო სწრაფად მუშაობს ვიდრე ლინქის მეთოდი.

 

 

ზოგადად ვიცი რომ ლინქი არის ყველაზე ნელი და დიდ პროექტებში ყოველთვის ჯობია ლინქისთვის გვერდის ავლა და სხვა მეთოდების გამოყენება.

 

პ.ს.

ეს პირველ სურათზე რაც არის იმისი სრული კოდი:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;
using System.Diagnostics;
using System.Linq.Expressions;

namespace PrivateCvladisDabruneba
{
    public class MyClass
    {
        private string paroli = "scripts";
    }



    class Program
    {

        static void Main(string[] args)
        {
            Stopwatch stopwatch = new Stopwatch();
            Console.WriteLine("Linq-is metodit");
            stopwatch.Start();

            MyClass mc = new MyClass();
            var migeba = Private_cvladis_migeba<MyClass, string>("paroli"); 
            string shedegi = migeba(mc); 
            Console.WriteLine(shedegi);

            stopwatch.Stop();
            Console.WriteLine(stopwatch.Elapsed.TotalMilliseconds);
            Console.ReadKey();
            
        }

        public static Func<T, R> Private_cvladis_migeba<T, R>(string cvladis_saxeli)
        {
            ParameterExpression param = Expression.Parameter(typeof(T), "arg");

            MemberExpression member = Expression.Field(param, cvladis_saxeli);

            LambdaExpression lambda = Expression.Lambda(typeof(Func<T, R>), member, param);

            Func<T, R> compiled = (Func<T, R>)lambda.Compile();

            return compiled;
        }

    }


}

ეს კი მეორე სურათზე რაც არის იმისი სრული კოდი:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Reflection;
using System.Diagnostics;
using System.Linq.Expressions;

namespace PrivateCvladisDabruneba
{
    public class MyClass
    {
        private string paroli = "scripts";
    }



    class Program
    {

        static void Main(string[] args)
        {
            Stopwatch stopwatch = new Stopwatch();
            Console.WriteLine("Expressions metodit");
            stopwatch.Start();

            MyClass myInstance = new MyClass();
            var fieldInfo = typeof(MyClass).GetField("paroli",
                                  BindingFlags.NonPublic | BindingFlags.Instance);
            var pass = fieldInfo.GetValue(myInstance);
            Console.WriteLine(pass);

            stopwatch.Stop();
            Console.WriteLine(stopwatch.Elapsed.TotalMilliseconds);
            Console.ReadKey();
        }

        public static Func<T, R> Private_cvladis_migeba<T, R>(string cvladis_saxeli)
        {
            ParameterExpression param = Expression.Parameter(typeof(T), "arg");

            MemberExpression member = Expression.Field(param, cvladis_saxeli);

            LambdaExpression lambda = Expression.Lambda(typeof(Func<T, R>), member, param);

            Func<T, R> compiled = (Func<T, R>)lambda.Compile();

            return compiled;
        }

    }


}

Share this post


Link to post
Share on other sites

ექსპრეშენის მეთოდში ალბათ რეფლექსიას გულისხმობ ჰო?

ამ შემთხვევაში შენ აკეთებ მხოლოდ ერთ ობიექტზე, და თან ითვლი კომპილაციის დროსაც, ანუ  ამას : 

var migeba = Private_cvladis_migeba<MyClass, string>("paroli"); 

უფრო დიდი დრო სჭირდება ვიდრე ამას:

var fieldInfo = typeof(MyClass).GetField("paroli",
                                  BindingFlags.NonPublic | BindingFlags.Instance);

მაგრამ სამაგიეროდ ამას:

string shedegi = migeba(mc); 

გაცილებით ნაკლები დრო სჭირდება ვიდრე ამას :

var pass = fieldInfo.GetValue(myInstance);

აი ამ კოდში ვქმნი 10000 ობიექტს და ორივე მეთოდს ვტესტავ :

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Linq;
using System.Linq.Expressions;
using System.Diagnostics;
class Program
{

    const int zoma = 10000;
    static void Main(string[] args)
    {
        
        reflection();
        Console.WriteLine("***************************************");
        linq();
        
        Console.ReadLine();
    }

    static void reflection()
    {
        MyClass[] array = new MyClass[zoma];

        for (int i = 0; i < array.Length; i++)
        {
            array = new MyClass();
        }

        MyClass myInstance = new MyClass();
        FieldInfo fieldInfo = typeof(MyClass).GetField("paroli", BindingFlags.NonPublic | BindingFlags.Instance);


        Stopwatch s =Stopwatch.StartNew();

        for (int i = 0; i < array.Length; i++)
        {
            var pass = fieldInfo.GetValue(array);
        }

        Console.WriteLine("refleqsia :  " + s.Elapsed.TotalMilliseconds);

    }


    static void linq()
    {
        MyClass[] array = new MyClass[zoma];

        for (int i = 0; i < array.Length; i++)
        {
            array = new MyClass();
        }

        var migeba = Private_cvladis_migeba<MyClass, string>("paroli");

        Stopwatch s = Stopwatch.StartNew();

        for (int i = 0; i < array.Length; i++)
        {
            string shedegi = migeba(array);
        }

        Console.WriteLine("linqi : " + s.Elapsed.TotalMilliseconds);

    }

    public static Func<T, R> Private_cvladis_migeba<T, R>(string cvladis_saxeli)
    {
        ParameterExpression param = Expression.Parameter(typeof(T), "arg");

        MemberExpression member = Expression.Field(param, cvladis_saxeli);

        LambdaExpression lambda = Expression.Lambda(typeof(Func<T, R>), member, param);

        Func<T, R> compiled = (Func<T, R>)lambda.Compile();

        return compiled;
    }
}
public class MyClass
{
    private string paroli = "scripts";
}

შედეგი დაახლოებით ასეთია :

 

8f4b6e531735.jpg

 

ასე რომ ერთი ობიექტიდა თუ გვინდა პრივატული ცვლადის მიღება მაშინ რეფლექსია სწრაფია, მაგრამ ბევრი ობიექტის შემთხვევაში Linq გაცილებით სწრაფად მუშაობს რადგან დიდი დრო მხოლოდ ლამბდას კომპილაციას სჭირდება და შემდეგ მისი გამოყენება ძალიან სწრაფად ხდება.

p.s.  release-ზე თუ დავაკომპილირებთ დაახლოებით ასეთი შედეგი იქნება:

 

ccad214dda95.jpg

Share this post


Link to post
Share on other sites

თაზო ბაღდავაძე, არასწორად აკეთებ, მთლიანი მეთოდი უნდა გაზომო და თანაც, როცა ერთხელ რთავ სტოპვოჩს მეორე გაცილებით სწრაფია, ცალცალკე გააკეთე ერთად ნუ აკეთებ, ორი სხვადასხვა პროექტით და მერე დადე შედეგები. მითუმეტეს კლასის მასივს რატომ ქმნი, ცვლადი დააბრუნებინე 10000-ჯერ. 10000 ობიექტს კი არ მქნი, 10000 კლასს ქმნი.

 

ხო მართლა, იმის თქმა დამავიწყდა, რომ შენ სანამ ლინქის მეთოდზე გადახვალ, არ აჩერებ პირველ სტოპვოჩს და ანუ პირველი სტოპვოჩი ითვლის მთლიან დროს. ამასთან, შენ მასივის კლასს ცალკე ქმნიდი ჩემს მეთოდში და მაიინსტანს კლასს კიდე ცალკე დამატებით. შენი Private_cvladis_migeba მეთოდს სჭირდება ძალიან ძალიან დიდი დრო. დავდებ შედეგებს.

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        const int zoma = 10000;


        static void Main(string[] args)
        {
            Stopwatch st = new Stopwatch();
            Console.WriteLine("linq");
            st.Start();
          //linq(); // amisi shedegia: 1118.0898 miliwami
          //reflection(); // amis shedegia 2.318 miliwami
            st.Stop();
            Console.WriteLine(st.Elapsed.TotalMilliseconds);
            Console.ReadLine();
        }

        static void reflection()
        {
            MyClass myInstance = new MyClass();

            for (int i = 0; i < 10000; i++)
            {
                FieldInfo fieldInfo = typeof(MyClass).GetField("paroli", BindingFlags.NonPublic | BindingFlags.Instance);
                var pass = fieldInfo.GetValue(myInstance);
            }
        }

        static void linq()
        {
            MyClass mc = new MyClass();

            for (int i = 0; i < 10000; i++)
            {
                var migeba = Private_cvladis_migeba<MyClass, string>("paroli");
                string shedegi = migeba(mc);
            }

        }

        public static Func<T, R> Private_cvladis_migeba<T, R>(string cvladis_saxeli)
        {
            ParameterExpression param = Expression.Parameter(typeof(T), "arg");


            MemberExpression member = Expression.Field(param, cvladis_saxeli);

            LambdaExpression lambda = Expression.Lambda(typeof(Func<T, R>), member, param);

            Func<T, R> compiled = (Func<T, R>)lambda.Compile();

            return compiled;
        }
    }

    public class MyClass
    {
        private string paroli = "scripts";
    }

}


შედეგები იყო ასეთი:

linq(); // amisi shedegia: 1118.0898 miliwami

reflection(); // amis shedegia 2.318 miliwami

 

 

აქედან ჩანს რომ ამ მეთოდის გამოყენება Private_cvladis_migeba არაფრით არ შეიძლება.

Share this post


Link to post
Share on other sites

მე მეთოდის გაზომვა არ მჭირდება, ვითვლი მხოლოდ ცვლადის მიღებისას დახარჯულ დროს, და ერთხელ რომ ვრთავ სთოპვოჩს მერე გაცლებით სწრაფი რატომაა? თუ იმას გულისხმობ რომ ჯერ რეფლექსიის ფუნქციაა გამოძახებული და მერე ლინქის, თუ გადაადგილებ იგივე შედეგი იქნება. და 10000 კლასის შექმნაში რას გულისხმობ ვერ ვხვდები


 აი შენ როგორ ამბობ ისე კოდი მთლიანი მეთოდი რომ გავზომოთ : 

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Linq;
using System.Linq.Expressions;
using System.Diagnostics;
class Program
{

    const int zoma = 100000;
    static void Main(string[] args)
    {
        Stopwatch s = Stopwatch.StartNew();

        linq();

        Console.WriteLine("linqi : " + s.Elapsed.TotalMilliseconds);

        Console.WriteLine("***************************************");

        Stopwatch s2 = Stopwatch.StartNew();

        reflection();

        Console.WriteLine("refleqsia :  " + s2.Elapsed.TotalMilliseconds);

        Console.ReadLine();
    }

    static void reflection()
    {
        MyClass[] array = new MyClass[zoma];

        for (int i = 0; i < array.Length; i++)
        {
            array = new MyClass();
        }

        MyClass myInstance = new MyClass();
        FieldInfo fieldInfo = typeof(MyClass).GetField("paroli", BindingFlags.NonPublic | BindingFlags.Instance);


       

        for (int i = 0; i < array.Length; i++)
        {
            var pass = fieldInfo.GetValue(array);
        }

     

    }


    static void linq()
    {
        MyClass[] array = new MyClass[zoma];

        for (int i = 0; i < array.Length; i++)
        {
            array = new MyClass();
        }

        var migeba = Private_cvladis_migeba<MyClass, string>("paroli");

     
        for (int i = 0; i < array.Length; i++)
        {
            string shedegi = migeba(array);
        }

      

    }

    public static Func<T, R> Private_cvladis_migeba<T, R>(string cvladis_saxeli)
    {
        ParameterExpression param = Expression.Parameter(typeof(T), "arg");

        MemberExpression member = Expression.Field(param, cvladis_saxeli);

        LambdaExpression lambda = Expression.Lambda(typeof(Func<T, R>), member, param);

        Func<T, R> compiled = (Func<T, R>)lambda.Compile();

        return compiled;
    }
}
public class MyClass
{
    private string paroli = "scripts";
}

აი შედეგი : f5ab636cba49.jpg

Share this post


Link to post
Share on other sites

თაზო ბაღდავაძე, ცალცალკე დათვალე, ჩემი მეთოდიდან მერე მაინინსტანს კლასი მოაცილე. და რაც მთავარია, სტოპწოცი გააჩერე მეთოდის შემდეგ.

 

ამერია რაღაცეები შენს ნაწერში. ყველა ვარიანტში ლინქის მეთოდის გამოყენება არ შეიძლება. აი შენი დაწერილი ტ,რ მეთოდი.

Share this post


Link to post
Share on other sites

ვერ ვხვდები რას ამბობ  :huh:


შენ კოდში გიწერია ეს:

static void linq()
{
MyClass mc = new MyClass();
for (int i = 0; i < 10000; i++)
{
var migeba = Private_cvladis_migeba<MyClass, string>("paroli");
string shedegi = migeba(mc);
}
} 

და უკვე ვთქვი რომ ეს :

var migeba = Private_cvladis_migeba<MyClass, string>("paroli"); 

უნდა გავაკეთოთ მხოლოდ ერთხელ და მოცემული კლასის ყველა ობიექტისთვის გამოვიყენოთ, და არა ყოველ ჯერზე თავიდან შევქმნათ, ამიტომ გაძლევს ეგეთ შედეგს

Share this post


Link to post
Share on other sites

ტყუილად ვლაპარაკობ, მარტივად რომ გითხრა შენი მეთოდი შეიტანე ციკლში

for (int i = 0; i < array.Length; i++)
            {
                var migeba = Private_cvladis_migeba<MyClass, string>("paroli");
                string shedegi = migeba(array);
            }

ასე. შენ რა შედეგებსაც იღებ ეგ იმიტომაა, რომ ამ მეთოდს ერთხელ იყენებ მარტო და მერე შედეგს ანუ სტრინგს აბრუნებინებ 10000-ჯერ და რა თქმა უნდა უბრალო სტრინგის 10000-ჯერ დაბრუნება უფრო სწრაფი იქნება ვიდრე გეთვალიუს გამოყენება. ეგ იგივეა რომ დავწერო string str = "scripts"; და ეს დავაბრუნებინო 10000-ჯერ. ამას ითვლი შენ.

 

აბა ეხლა ადექი და ეგ მეთოდი შეიტანე ციკლში რომ 10000-ჯერ მოხდეს მაგ მეთოდის გამოყენება და ნახე რა მოხდება. 10000-ჯერ რომ გამოიყენებ კატასტროფული დრო სჭირდება.

 

 

ერთხელ რატომ უნდა გამოიყენო, როდესაც შენ მეთოდს იყენებ ერთხელ და  მეთოდი უნდა გამოიყენო 10000-ჯერ რომ გაიგო როგორ მუშაობს.რეალურად მეთოდის მუშაობის დროს არ თვლი, თვლი სტრინგის 10000-ჯერ დაბრუნების დროს.

Share this post


Link to post
Share on other sites

მეთოდის მუშაობა არის ეს: 

string shedegi = migeba(mc);

და ეს არის მეთოდის ასე ვთქვათ გამზადება

var migeba = Private_cvladis_migeba<MyClass, string>("paroli");

და ახლა ეს Migeba შეგვიძლია გამოვიყენოთ myclass-ის ობიექტებისთვის რამდენჯერაც გვინდა, ამ მეორე კოდის ციკლში ჩაწერა უზარობაა ერთი და იგივე კლასის ობიექტებთან მუშაობის დროს

Share this post


Link to post
Share on other sites

 

 

ხო და, მოკლედ, როცა ლექციაზე იქნებით და გეტყვიან იმას რაც ზემოთ დავწერე, ააფარეთ ეს კოდი :დ

 

 

  წესით ლექციაზე უნდა დაგიყოლონ, რომ ეს ყველაფერი თეორიულად ოოპს მცნებიდან გამომდინარეობს , მაგრამ პრაქტიკულად დატოვებულია ესე ვთქვათ "ხვრელი" ამ შეზღუდვას რომ აუარონ გვერდი (რადგან ძალიან დაბალი დონეზე საჭიროა წვდომა გარკვეული კატეგორიის ამოცანებში ამ ყველაფერთან). ბევრ ენაში არის ესეთი  "ხვრელები" c#, java, delphi  რეფლექსიით. ამ ყველაფრის მუღამი არის ის რომ დინამიურად შექმნა რაღაც კოდი რომელიც შესრულდება დინამიურადვე run timeზე. ერთ-ერთი მაგალითია სერიალიზაცია/დესერიალიზაცია ობიექტის, ობიექტის თვითონ მდგომარეობის შენახვა.  

Share this post


Link to post
Share on other sites

თაზო ბაღდავაძე, მაგ შემთხვევაში 25 000 ციკლის ქვემოთ რეფლექსია უკეთეს შედეგებს აჩვენებს და რაც უფრო ნაკლებია ციკლი მით უფრო უკეთესს. და 25 000-ის ზემოთ ეგ მეთოდი რასაც შენ ამბობ ერთხელ გამოყენებით უკეთეს შედეგებს აჩვენებს რაც უფრო მეტია ციკლების რაოდენობა.

 

მაგ მეთოდის მუშაობის სიჩქარე ძალიან დაბალია და ვთქვათ 100 სხვადასხვა ცვლადი რომ იყოს მისაღები (რეალურად ცვლადის მნიშვნელობის მიღება მხოლოდ ერთხელ გჭირდება) აშკარად ცუდ შედეგებს აჩვენებს.

 

ეს არის ერთი ციკლის შედეგები.

ztpLjnU.png

აქედან კარგად ჩანს, შენი ლინქის მეთოდი რატომ ანდომებს ნაკლებ დროს 25 000 ციკლის ზემოთ.

ე.ი მაგ მეთოდის გამოყენება მარტო იმ შემთხვევაშია უკეთსი, როცა კოდში დაგჭირდება ერთი ცვლადის მნიშვნელობის მიღება 25 000 ან მეტჯერ.

თუმცა ეგეც მეეჭვება, იმიტომ რომ მე მაგალითად ერთხელ მივიღებდი მნიშვნელობას, ჩავწერდი სტრინგის ცვლადში და მერე იმას გამოვიყენებდი 1000 000-ჯერ თუ რამდენიც საწირო იქნება. გაცილებით უფრო სწრაფი გამოვა. ამიტომაც ვფიქრობ, რეფლექსია უკეთესია.

Share this post


Link to post
Share on other sites

თაზო ბაღდავაძე, მაგ შემთხვევაში 25 000 ციკლის ქვემოთ რეფლექსია უკეთეს შედეგებს აჩვენებს და რაც უფრო ნაკლებია ციკლი მით უფრო უკეთესს. და 25 000-ის ზემოთ ეგ მეთოდი რასაც შენ ამბობ ერთხელ გამოყენებით უკეთეს შედეგებს აჩვენებს რაც უფრო მეტია ციკლების რაოდენობა.

 

მაგ მეთოდის მუშაობის სიჩქარე ძალიან დაბალია და ვთქვათ 100 სხვადასხვა ცვლადი რომ იყოს მისაღები (რეალურად ცვლადის მნიშვნელობის მიღება მხოლოდ ერთხელ გჭირდება) აშკარად ცუდ შედეგებს აჩვენებს.

 

ეს არის ერთი ციკლის შედეგები.

ztpLjnU.png

აქედან კარგად ჩანს, შენი ლინქის მეთოდი რატომ ანდომებს ნაკლებ დროს 25 000 ციკლის ზემოთ.

ე.ი მაგ მეთოდის გამოყენება მარტო იმ შემთხვევაშია უკეთსი, როცა კოდში დაგჭირდება ერთი ცვლადის მნიშვნელობის მიღება 25 000 ან მეტჯერ.

თუმცა ეგეც მეეჭვება, იმიტომ რომ მე მაგალითად ერთხელ მივიღებდი მნიშვნელობას, ჩავწერდი სტრინგის ცვლადში და მერე იმას გამოვიყენებდი 1000 000-ჯერ თუ რამდენიც საწირო იქნება. გაცილებით უფრო სწრაფი გამოვა. ამიტომაც ვფიქრობ, რეფლექსია უკეთესია.

 

მაგას ვიძახდი მეც ზუსტად, წეღანაც დავწერე რომ როცა ნაკლები რაოდენობაა, რეფლესიის გამოყენება სჯობს

Share this post


Link to post
Share on other sites

თაზო ბაღდავაძე, შენი მეთოდი მართო მეთოდი და გამოყენება როგორ უნდა ეგ მეტი არაფერი. რამდენიმე სიტყვით აღწერაც დაურთე და აღარ დაიკარგება ეგ მეთოდი.

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this  

×