c# - কোনও প্রকার থেকে কীভাবে একটি নতুন অবজেক্ট উদাহরণ তৈরি করা যায়




.net performance (8)

আপনি যদি ডিফল্ট কনস্ট্রাক্টর ব্যবহার করতে চান তবে System.Activator ব্যবহার করে System.Activator আগে উপস্থাপন করা সম্ভবত সবচেয়ে সুবিধাজনক। যাইহোক, যদি টাইপটিতে একটি ডিফল্ট নির্মাণকারীর অভাব থাকে বা আপনাকে একটি ডিফল্ট নয় এমন একটি ব্যবহার করতে হয়, তারপরে একটি বিকল্প হ'ল প্রতিবিম্ব বা System.ComponentModel.TypeDescriptor ব্যবহার করা। প্রতিবিম্বের ক্ষেত্রে, কেবলমাত্র প্রকারের নামটি (এটির নামের স্থান সহ) জানা যথেষ্ট।

প্রতিবিম্ব ব্যবহার করে উদাহরণ:

ObjectType instance = 
    (ObjectType)System.Reflection.Assembly.GetExecutingAssembly().CreateInstance(
        typeName: objectType.FulName, // string including namespace of the type
        ignoreCase: false,
        bindingAttr: BindingFlags.Default,
        binder: null,  // use default binder
        args: new object[] { args, to, constructor },
        culture: null, // use CultureInfo from current thread
        activationAttributes: null
    );

TypeDescriptor ব্যবহার করে উদাহরণ:

ObjectType instance = 
    (ObjectType)System.ComponentModel.TypeDescriptor.CreateInstance(
        provider: null, // use standard type description provider, which uses reflection
        objectType: objectType,
        argTypes: new Type[] { types, of, args },
        args: new object[] { args, to, constructor }
    );

সংকলন-সময়ে কোনও অবজেক্টের ধরণটি সর্বদা জানা নাও থাকতে পারে তবে Type একটি উদাহরণ তৈরি করতে হতে পারে। আপনি কোনও Type থেকে কীভাবে একটি নতুন অবজেক্টের উদাহরণ পাবেন?


আমি এই প্রশ্নটি পার করতে পারি কারণ আমি স্বেচ্ছাসেবী শ্রেণীর জন্য একটি সাধারণ ক্লোনঅজেক্ট পদ্ধতি প্রয়োগ করতে চেয়েছিলাম (একটি ডিফল্ট নির্মাণকারী সহ)

জেনেরিক পদ্ধতিতে আপনার প্রয়োজন হতে পারে যে টাইপটি নতুন () প্রয়োগ করে।

Public Function CloneObject(Of T As New)(ByVal src As T) As T
    Dim result As T = Nothing
    Dim cloneable = TryCast(src, ICloneable)
    If cloneable IsNot Nothing Then
        result = cloneable.Clone()
    Else
        result = New T
        CopySimpleProperties(src, result, Nothing, "clone")
    End If
    Return result
End Function

জেনারিক অ-জেনার ধরে ধরে ধরণের ডিফল্ট কনস্ট্রাক্টর রয়েছে এবং যদি এটি না ঘটে তবে একটি ব্যতিক্রম ধরুন।

Public Function CloneObject(ByVal src As Object) As Object
    Dim result As Object = Nothing
    Dim cloneable As ICloneable
    Try
        cloneable = TryCast(src, ICloneable)
        If cloneable IsNot Nothing Then
            result = cloneable.Clone()
        Else
            result = Activator.CreateInstance(src.GetType())
            CopySimpleProperties(src, result, Nothing, "clone")
        End If
    Catch ex As Exception
        Trace.WriteLine("!!! CloneObject(): " & ex.Message)
    End Try
    Return result
End Function

এই সমস্যার একটি বাস্তবায়ন হ'ল ধরণের প্যারামিটার-কম কনস্ট্রাক্টরকে কল করার চেষ্টা করা:

public static object GetNewObject(Type t)
{
    try
    {
        return t.GetConstructor(new Type[] { }).Invoke(new object[] { });
    }
    catch
    {
        return null;
    }
}

এখানে একটি সাধারণ পদ্ধতি রয়েছে যা জেনেরিক পদ্ধতিতে রয়েছে:

public static T GetNewObject<T>()
{
    try
    {
        return (T)typeof(T).GetConstructor(new Type[] { }).Invoke(new object[] { });
    }
    catch
    {
        return default(T);
    }
}

এটি বেশ সহজ। ধরে নিন যে আপনার ক্লাসের নাম Car এবং নাম স্থানটি Vehicles , তারপরে প্যারামিটারটিকে Vehicles.Car হিসাবে চিহ্নিত করুন Vehicles.Car এর মতো আপনি যে কোনও শ্রেণীর যে কোনও উদাহরণ গতিশীলভাবে তৈরি করতে পারেন।

public object GetInstance(string strNamesapace)
{         
     Type t = Type.GetType(strNamesapace); 
     return  Activator.CreateInstance(t);         
}

যদি আপনার পুরো যোগ্যতার নাম (যেমন, এই ক্ষেত্রে Type.GetType ) অন্য কোনও সমাবেশে থাকে তবে Type.GetType হবে। এই জাতীয় ক্ষেত্রে, আপনি সমস্ত অ্যাসেম্বলির মধ্য দিয়ে লুপ পেয়েছেন এবং প্রকারটি সন্ধান করুন। তার জন্য আপনি নীচের কোডটি ব্যবহার করতে পারেন

public object GetInstance(string strFullyQualifiedName)
{
     Type type = Type.GetType(strFullyQualifiedName);
     if (type != null)
         return Activator.CreateInstance(type);
     foreach (var asm in AppDomain.CurrentDomain.GetAssemblies())
     {
         type = asm.GetType(strFullyQualifiedName);
         if (type != null)
             return Activator.CreateInstance(type);
     }
     return null;
 }

এবং উপরের পদ্ধতিটি কল করে আপনি উদাহরণটি পেতে পারেন।

object objClassInstance = GetInstance("Vehicles.Car");

প্রতিবিম্ব ব্যবহার ছাড়া:

private T Create<T>() where T : class, new()
{
    return new T();
}

যদি এটি এমন কোনও কিছুর জন্য হয় যেটিকে একটি অ্যাপ্লিকেশন উদাহরণ হিসাবে অনেক বলা হয়ে থাকে তবে এটি অ্যাক্টিভেটর বা ConstructorInfo.Invoke() ইনভোক ConstructorInfo.Invoke() ব্যবহার না করে ডায়নামিক কোড সংকলন এবং ক্যাশে করা অনেক দ্রুত faster ডায়নামিক সংকলনের জন্য দুটি সহজ বিকল্প লিনক এক্সপ্রেশন বা কিছু সাধারণ IL অপকডস এবং ডায়নামিকমেথোদ সংকলিত। যেভাবেই হোক, আপনি যখন টাইট লুপ বা একাধিক কল পেতে শুরু করেন তখন পার্থক্য বিশাল।


সংকলিত এক্সপ্রেশন সেরা উপায়! (রানটাইমে বারবার উদাহরণ তৈরি করার জন্য পারফরম্যান্সের জন্য)।

static readonly Func<X> YCreator = Expression.Lambda<Func<X>>(
   Expression.New(typeof(Y).GetConstructor(Type.EmptyTypes))
 ).Compile();

X x = YCreator();

পরিসংখ্যান (2012):

    Iterations: 5000000
    00:00:00.8481762, Activator.CreateInstance(string, string)
    00:00:00.8416930, Activator.CreateInstance(type)
    00:00:06.6236752, ConstructorInfo.Invoke
    00:00:00.1776255, Compiled expression
    00:00:00.0462197, new

পরিসংখ্যান (2015, নেট নেট 4.5, এক্স 64):

    Iterations: 5000000
    00:00:00.2659981, Activator.CreateInstance(string, string)
    00:00:00.2603770, Activator.CreateInstance(type)
    00:00:00.7478936, ConstructorInfo.Invoke
    00:00:00.0700757, Compiled expression
    00:00:00.0286710, new

পরিসংখ্যান (2015,। নেট 4.5, x86):

    Iterations: 5000000
    00:00:00.3541501, Activator.CreateInstance(string, string)
    00:00:00.3686861, Activator.CreateInstance(type)
    00:00:00.9492354, ConstructorInfo.Invoke
    00:00:00.0719072, Compiled expression
    00:00:00.0229387, new

পরিসংখ্যান (2017, লিনকিউপ্যাড 5.22.02 / এক্স 64 /। নেট 4.6):

    Iterations: 5000000
    No args
    00:00:00.3897563, Activator.CreateInstance(string assemblyName, string typeName)
    00:00:00.3500748, Activator.CreateInstance(Type type)
    00:00:01.0100714, ConstructorInfo.Invoke
    00:00:00.1375767, Compiled expression
    00:00:00.1337920, Compiled expression (type)
    00:00:00.0593664, new
    Single arg
    00:00:03.9300630, Activator.CreateInstance(Type type)
    00:00:01.3881770, ConstructorInfo.Invoke
    00:00:00.1425534, Compiled expression
    00:00:00.0717409, new

পরিসংখ্যান (2019, x64 /। নেট 4.8):

Iterations: 5000000
No args
00:00:00.3287835, Activator.CreateInstance(string assemblyName, string typeName)
00:00:00.3122015, Activator.CreateInstance(Type type)
00:00:00.8035712, ConstructorInfo.Invoke
00:00:00.0692854, Compiled expression
00:00:00.0662223, Compiled expression (type)
00:00:00.0337862, new
Single arg
00:00:03.8081959, Activator.CreateInstance(Type type)
00:00:01.2507642, ConstructorInfo.Invoke
00:00:00.0671756, Compiled expression
00:00:00.0301489, new

পরিসংখ্যান (2019, x64 /। নেট কোর 3.0):

Iterations: 5000000
No args
00:00:00.3226895, Activator.CreateInstance(string assemblyName, string typeName)
00:00:00.2786803, Activator.CreateInstance(Type type)
00:00:00.6183554, ConstructorInfo.Invoke
00:00:00.0483217, Compiled expression
00:00:00.0485119, Compiled expression (type)
00:00:00.0434534, new
Single arg
00:00:03.4389401, Activator.CreateInstance(Type type)
00:00:01.0803609, ConstructorInfo.Invoke
00:00:00.0554756, Compiled expression
00:00:00.0462232, new

সম্পূর্ণ কোড:

static X CreateY_New()
{
    return new Y();
}

static X CreateY_New_Arg(int z)
{
    return new Y(z);
}

static X CreateY_CreateInstance()
{
    return (X)Activator.CreateInstance(typeof(Y));
}

static X CreateY_CreateInstance_String()
{
    return (X)Activator.CreateInstance("Program", "Y").Unwrap();
}

static X CreateY_CreateInstance_Arg(int z)
{
    return (X)Activator.CreateInstance(typeof(Y), new object[] { z, });
}

private static readonly System.Reflection.ConstructorInfo YConstructor =
    typeof(Y).GetConstructor(Type.EmptyTypes);
private static readonly object[] Empty = new object[] { };
static X CreateY_Invoke()
{
    return (X)YConstructor.Invoke(Empty);
}

private static readonly System.Reflection.ConstructorInfo YConstructor_Arg =
    typeof(Y).GetConstructor(new[] { typeof(int), });
static X CreateY_Invoke_Arg(int z)
{
    return (X)YConstructor_Arg.Invoke(new object[] { z, });
}

private static readonly Func<X> YCreator = Expression.Lambda<Func<X>>(
   Expression.New(typeof(Y).GetConstructor(Type.EmptyTypes))
).Compile();
static X CreateY_CompiledExpression()
{
    return YCreator();
}

private static readonly Func<X> YCreator_Type = Expression.Lambda<Func<X>>(
   Expression.New(typeof(Y))
).Compile();
static X CreateY_CompiledExpression_Type()
{
    return YCreator_Type();
}

private static readonly ParameterExpression YCreator_Arg_Param = Expression.Parameter(typeof(int), "z");
private static readonly Func<int, X> YCreator_Arg = Expression.Lambda<Func<int, X>>(
   Expression.New(typeof(Y).GetConstructor(new[] { typeof(int), }), new[] { YCreator_Arg_Param, }),
   YCreator_Arg_Param
).Compile();
static X CreateY_CompiledExpression_Arg(int z)
{
    return YCreator_Arg(z);
}

static void Main(string[] args)
{
    const int iterations = 5000000;

    Console.WriteLine("Iterations: {0}", iterations);

    Console.WriteLine("No args");
    foreach (var creatorInfo in new[]
    {
        new {Name = "Activator.CreateInstance(string assemblyName, string typeName)", Creator = (Func<X>)CreateY_CreateInstance},
        new {Name = "Activator.CreateInstance(Type type)", Creator = (Func<X>)CreateY_CreateInstance},
        new {Name = "ConstructorInfo.Invoke", Creator = (Func<X>)CreateY_Invoke},
        new {Name = "Compiled expression", Creator = (Func<X>)CreateY_CompiledExpression},
        new {Name = "Compiled expression (type)", Creator = (Func<X>)CreateY_CompiledExpression_Type},
        new {Name = "new", Creator = (Func<X>)CreateY_New},
    })
    {
        var creator = creatorInfo.Creator;

        var sum = 0;
        for (var i = 0; i < 1000; i++)
            sum += creator().Z;

        var stopwatch = new Stopwatch();
        stopwatch.Start();
        for (var i = 0; i < iterations; ++i)
        {
            var x = creator();
            sum += x.Z;
        }
        stopwatch.Stop();
        Console.WriteLine("{0}, {1}", stopwatch.Elapsed, creatorInfo.Name);
    }

    Console.WriteLine("Single arg");
    foreach (var creatorInfo in new[]
    {
        new {Name = "Activator.CreateInstance(Type type)", Creator = (Func<int, X>)CreateY_CreateInstance_Arg},
        new {Name = "ConstructorInfo.Invoke", Creator = (Func<int, X>)CreateY_Invoke_Arg},
        new {Name = "Compiled expression", Creator = (Func<int, X>)CreateY_CompiledExpression_Arg},
        new {Name = "new", Creator = (Func<int, X>)CreateY_New_Arg},
    })
    {
        var creator = creatorInfo.Creator;

        var sum = 0;
        for (var i = 0; i < 1000; i++)
            sum += creator(i).Z;

        var stopwatch = new Stopwatch();
        stopwatch.Start();
        for (var i = 0; i < iterations; ++i)
        {
            var x = creator(i);
            sum += x.Z;
        }
        stopwatch.Stop();
        Console.WriteLine("{0}, {1}", stopwatch.Elapsed, creatorInfo.Name);
    }
}

public class X
{
  public X() { }
  public X(int z) { this.Z = z; }
  public int Z;
}

public class Y : X
{
    public Y() {}
    public Y(int z) : base(z) {}
}

public AbstractType New
{
    get
    {
        return (AbstractType) Activator.CreateInstance(GetType());
    }
}






types