एक प्रकार से एक नया ऑब्जेक्ट उदाहरण प्राप्त करें

संकलन समय पर किसी ऑब्जेक्ट के प्रकार को हमेशा नहीं पता हो सकता है, लेकिन टाइप का उदाहरण बनाने की आवश्यकता हो सकती है। आप एक प्रकार से एक नया ऑब्जेक्ट उदाहरण कैसे प्राप्त करते हैं?

0
जोड़ा संपादित
विचारों: 1
क्या आप आर्कजीआईएस 10 में बेस लेयर के बारे में बात कर रहे हैं?
जोड़ा लेखक Devdatta Tengshe, स्रोत
मुझे लगता है कि वह बेस कस्टम कस्टमर क्लास का उपयोग कर कस्टम लेयर को लागू करने के बारे में बात कर रहा है।
जोड़ा लेखक Reed Copsey, स्रोत

13 उत्तर

क्या आपने BaseCustomGlobeLayer इसके बजाए?

Update: I just tried that and it doesn't work. I then derived from BaseCustomLayer then implemented IGraphicsContainer3D and was able to add it to the scene without getting an error.

2
जोड़ा
यहां फॉलोअप प्रश्न बनाया गया gis.stackexchange.com/questions/18301/…
जोड़ा लेखक saint_groceon, स्रोत
कोलेलास जो ILayerEvents को कार्यान्वित करते हैं ऐसा प्रतीत होता है कि वे सभी आउटबाउंड इंटरफ़ेस (ग्लोब और 3 डी परतों को छोड़कर) के रूप में ऐसा करते हैं। एक अच्छा सवाल होगा: मैं सी # में कस्टम कक्षाओं के लिए एकाधिक आउटबाउंड इंटरफेस कैसे कार्यान्वित करूं?
जोड़ा लेखक saint_groceon, स्रोत
मुझे लगता है कि एक लापता आउटबाउंड इंटरफ़ेस से संबंधित एक और मुद्दा है। आर्कमैप में फीचरलेयर कोक्लास एक आउटबाउंड इंटरफ़ेस के रूप में ILayerEvents लागू करता है। मुझे लगता है कि graphicslayer3d के लिए दस्तावेज़ </ए> गलत है और यह कि ILayerEvents को आउटबाउंड होना चाहिए क्योंकि यह फ
जोड़ा लेखक saint_groceon, स्रोत
@ReedCopsey ओएमडी देख रहा है मैं देखता हूं कि GraphicsLayer3D आउटबाउंड इंटरफेस के रूप में IActiveViewEvents लागू करता है। मुझे संदेह है कि आइटम हटाया गया ग्राफिक्स हटा दिए जाने पर आग लगने की जरूरत है।
जोड़ा लेखक saint_groceon, स्रोत
मुझे यकीन नहीं था, जब तक मैंने कोशिश की। आप सही हैं- यह ArcScene के साथ काम नहीं करता है।
जोड़ा लेखक saint_groceon, स्रोत
IGraphicsContainer3D कुंजी प्रतीत होता है। धन्यवाद!
जोड़ा लेखक Thejesh GN, स्रोत
क्या यह केवल आर्कग्लोब के लिए नहीं है? क्या यह आर्कसेन में भी काम करता है?
जोड़ा लेखक Reed Copsey, स्रोत
@ डीबीकर क्या आपको अंत में काम करने के लिए मिला? मैंने यह कोशिश की है, और जब यह बिना किसी त्रुटि के जोड़ता है, व्यवहार "साफ" नहीं होता है (यानी: IGraphicsContainer3D से ग्राफिक्स कभी नहीं हटाएंगे, आदि) ...
जोड़ा लेखक Reed Copsey, स्रोत
@ किर्ककुयकेन्डल मैंने अभी पूरे IActiveViewEvents (और ILayerEvents) को लागू किया है और अभी भी वही अजीब व्यवहार प्राप्त कर रहा है ...
जोड़ा लेखक Reed Copsey, स्रोत
ऐसा नहीं है कि मैं ग्राफिक्स को हटा रहा हूं - यहां तक ​​कि झूठ पर परत दृश्यता को सेट करने से वस्तुओं को साफ़ नहीं किया जाता है।
जोड़ा लेखक Reed Copsey, स्रोत

इस समस्या का एक कार्यान्वयन प्रकार के पैरामीटर-कम कन्स्ट्रक्टर को कॉल करने का प्रयास करना है:

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

एक सामान्य विधि में निहित एक ही दृष्टिकोण है:

public static T GetNewObject()
{
    try
    {
        return (T)typeof(T).GetConstructor(new Type[] { }).Invoke(new object[] { });
    }
    catch
    {
        return default(T);
    }
}
0
जोड़ा
अपवाद संचालित प्रोग्रामिंग? ऐसा लगता है कि जब आप रचनाकारों को निर्धारित करने के लिए बस प्रकार पर प्रतिबिंबित कर सकते हैं तो यह बहुत खराब कार्यान्वयन की तरह लगता है।
जोड़ा लेखक Firoso, स्रोत

रूट <�कोड> सिस्टम नेमस्पेस के भीतर सक्रियकर्ता वर्ग बहुत शक्तिशाली है।

कन्स्ट्रक्टर और ऐसे में पैरामीटर पास करने के लिए बहुत सारे अधिभार हैं। यहां दस्तावेज देखें:

http://msdn.microsoft.com/en- हमें / पुस्तकालय / system.activator.createinstance.aspx

या (नया रास्ता)

https://docs.microsoft.com/en- हमें / डॉटनैट / API / system.activator.createinstance

यहां कुछ सरल उदाहरण दिए गए हैं:

ObjectType instance = (ObjectType)Activator.CreateInstance(objectType);

ObjectType instance = (ObjectType)Activator.CreateInstance("MyAssembly","MyNamespace.ObjectType");
0
जोड़ा
आखिर में यह पाया गया है, लेकिन दूसरी कॉल बिल्कुल सही नहीं है, एक उद्धरण और पार्स उलटा हुआ है, होना चाहिए: ऑब्जेक्ट टाइप टाइप = (ऑब्जेक्ट टाइप) एक्टिवेटर। क्रिएट इंस्टेंस ("माईएस्प्लर", "माईनेम्सपा और ज़ेनज; सीई ऑब्जेक्ट टाइप");
जोड़ा लेखक kevinc, स्रोत
वास्तविक वस्तु का वास्तविक प्रकार प्राप्त करने के लिए आपको 'अनवर्र ()' को कॉल करने की आवश्यकता है: कंक्रीट टाइप उदाहरण = (कंक्रीट टाइप) एक्टिवेटर। क्रिएट इंस्टेंस (ऑब्जेक्ट टाइप)। अनवरप ();
जोड़ा लेखक Ε Г И І И О, स्रोत

प्रतिबिंब के उपयोग के बिना:

private T Create() where T : class, new()
{
    return new T();
}
0
जोड़ा
आप संकलन समय पर सभी संभावित प्रकारों को जानते हैं, लेकिन आप नहीं जानते कि किस कार्यान्वयन को रनटाइम पर उपयोग किया जाएगा।
जोड़ा लेखक Robert P., स्रोत
यदि आप कारखानों में सामान्य वर्गों और इंटरफेस के साथ काम करते हैं, तो इंटरफ़ेस लागू करने वाले प्रकारों को अस्थिर किया जाना चाहिए।
जोड़ा लेखक Robert P., स्रोत
एक नया टी (); अगर टी पैरामीटर रहित कन्स्ट्रक्टर के साथ संदर्भ प्रकार नहीं है तो विफल हो जाएगा, यह विधियां टी संदर्भ संदर्भ प्रकार सुनिश्चित करने के लिए बाधाओं का उपयोग करती हैं और इसमें एक कन्स्ट्रक्टर है।
जोड़ा लेखक Robert P., स्रोत
तो टी रनटाइम पर भिन्न हो सकता है। उपयोगी अगर आप व्युत्पन्न प्रकार के साथ काम करते हैं।
जोड़ा लेखक Robert P., स्रोत
@RobertP। आप रनटाइम पर नए प्रकार बना सकते हैं। ऐसा कोई नियम नहीं है जो कहता है कि आप संकलन समय पर सभी प्रकार के बारे में जानते हैं। और नहीं, जेनेरिक के साथ मेरा मतलब नहीं है। आप पूरी तरह से नए प्रकार बना सकते हैं, और रनटाइम पर सभी फ़ील्ड, गुण और विधियां इत्यादि जोड़ सकते हैं। एक साधारण मामला भी है जहां आप एक ऐसे प्रकार का उदाहरण बनाना चाहते हैं जो एक असेंबली में है जो संकलन समय पर ज्ञात नहीं है। यह काफी आम है।
जोड़ा लेखक AnorZaken, स्रोत
रनटाइम पर टी कैसे भिन्न हो सकता है? क्या आपको << बनाने के लिए डिज़ाइन समय पर टी को नहीं जानना है?
जोड़ा लेखक Kyle Delaney, स्रोत
यह कैसे उपयोगी है? आपको उस विधि को कॉल करने के लिए पहले से ही टाइप करना होगा, और यदि आप उस प्रकार को जानते हैं जिसे आप बिना किसी विशेष विधि के बना सकते हैं।
जोड़ा लेखक Kyle Delaney, स्रोत

मैं इस सवाल पर जा सकता हूं क्योंकि मैं मनमाने ढंग से कक्षा के लिए एक सरल क्लोनऑब्जेक्ट विधि को कार्यान्वित करना चाहता था (एक डिफ़ॉल्ट कन्स्ट्रक्टर के साथ)

जेनेरिक विधि के साथ आप आवश्यकता कर सकते हैं कि प्रकार नए() लागू करता है।

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
0
जोड़ा

जेनेरिक टी टी = नया टी (); काम नहीं करेगा?

0
जोड़ा
असल में, यह एक सामान्य वर्ग / विधि में होगा, लेकिन किसी दिए गए "प्रकार" के लिए नहीं।
जोड़ा लेखक Brady Moritz, स्रोत
ObjectType instance = (ObjectType)Activator.CreateInstance(objectType);

सक्रियकर्ता वर्ग में एक सामान्य संस्करण है जो इसे थोड़ा आसान बनाता है:

ObjectType instance = Activator.CreateInstance();
0
जोड़ा
निश्चित रूप से @ केविन। ऐसा ऑपरेशन can? T एक स्थाई रूप से टाइप की गई भाषा में काम करता है क्योंकि यह समझ में नहीं आता है। आप अज्ञात प्रकार की वस्तु पर विधियों का आह्वान नहीं कर सकते हैं। इस बीच (= इस उत्तर को लिखने के बाद) सी # को गतिशील निर्माण मिला है जो करता है ऐसी संरचनाओं को अनुमति देता है लेकिन अधिकांश उद्देश्यों के लिए यह उत्तर अभी भी इसे कवर करता है।
जोड़ा लेखक Konrad Rudolph, स्रोत
@AnorZaken मेरी टिप्पणी रनटाइम पर प्रकार बनाने के बारे में कुछ भी नहीं कहती है। बेशक आप ऐसा कर सकते हैं, लेकिन आप उन्हें उसी संदर्भ में स्थिर रूप से का उपयोग नहीं कर सकते हैं (आप कोर्स के पूर्ण सांख्यिकीय रूप से संकलित प्रोग्राम होस्ट कर सकते हैं)। वह सब मेरी टिप्पणी कह रही है।
जोड़ा लेखक Konrad Rudolph, स्रोत
इसके अलावा यह रनटाइम टाइप टी के लिए काम नहीं करता है।
जोड़ा लेखक Kevin P. Rice, स्रोत
@ कोनराड रुडॉल्फ आह क्षमा करें, इस तरह के एक ऑपरेशन को गलत तरीके से परिभाषित करने के लिए गलत तरीके से व्याख्या की गई है जिसे केवल रनटाइम पर जाना जाता है; एक सामान्य प्रकार पैरामीटर के रूप में रनटाइम प्रकार का उपयोग कर अर्थ के बजाय।
जोड़ा लेखक AnorZaken, स्रोत
@ कोनराड रुडॉल्फ बिल्कुल सही नहीं है। सी # करता है आपको रनटाइम पर नए प्रकार बनाने की अनुमति देता है। आप उन पर कुछ भी नहीं कह सकते एक स्थिर रूप से सुरक्षित तरीके से । तो हाँ, आप आधा सही हैं। लेकिन अधिक यथार्थवादी रूप से आपको इसकी आवश्यकता होती है जब आप रनटाइम पर असेंबली लोड करते हैं, जिसका अर्थ है कि प्रकार संकलन समय पर ज्ञात नहीं है। यदि आप ऐसा नहीं कर पा रहे हैं तो सी # गंभीर रूप से सीमित होगा। मेरा मतलब है कि आपने इसे स्वयं साबित कर दिया है: एक्टिवेटर विधि किस प्रकार एक प्रकार-उदाहरण काम करती है? जब एमएस ने एक्टिवेटर क्लास लिखा था तो उनके पास लिखने वाले किसी भी भविष्य के प
जोड़ा लेखक AnorZaken, स्रोत

संकलित अभिव्यक्ति सबसे अच्छा तरीका है! (रनटाइम में बार-बार उदाहरण बनाने के लिए प्रदर्शन के लिए)।

static readonly Func YCreator = Expression.Lambda>(
   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, x64):

    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, LINQPad 5.22.02 / x64 / .NET 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

पूरा कोड:

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 YCreator = Expression.Lambda>(
   Expression.New(typeof(Y).GetConstructor(Type.EmptyTypes))
).Compile();
static X CreateY_CompiledExpression()
{
    return YCreator();
}

private static readonly Func YCreator_Type = Expression.Lambda>(
   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 YCreator_Arg = Expression.Lambda>(
   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)CreateY_CreateInstance},
        new {Name = "Activator.CreateInstance(Type type)", Creator = (Func)CreateY_CreateInstance},
        new {Name = "ConstructorInfo.Invoke", Creator = (Func)CreateY_Invoke},
        new {Name = "Compiled expression", Creator = (Func)CreateY_CompiledExpression},
        new {Name = "Compiled expression (type)", Creator = (Func)CreateY_CompiledExpression_Type},
        new {Name = "new", Creator = (Func)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)CreateY_CreateInstance_Arg},
        new {Name = "ConstructorInfo.Invoke", Creator = (Func)CreateY_Invoke_Arg},
        new {Name = "Compiled expression", Creator = (Func)CreateY_CompiledExpression_Arg},
        new {Name = "new", Creator = (Func)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) {}
}
0
जोड़ा
शायद उदाहरण?
जोड़ा लेखक ajeh, स्रोत
क्या यह अभी भी उपयोगी है जब आप नहीं जानते कि किस प्रकार X रनटाइम पर है?
जोड़ा लेखक ajeh, स्रोत
इसके अलावा TypeDescriptor.CreateInstance ( stackoverflow.com/a/17797389/1242 देखें) जो टाइपडिस्क्रिप्टर के साथ उपयोग किए जाने पर तेज़ हो सकता है .AddProvider
जोड़ा लेखक Lars Truijens, स्रोत
@ सर्ज-टीएम नो, अगर टाइप एक्स रनटाइम टाइप है तो यह काम नहीं करेगा।
जोड़ा लेखक NetMage, स्रोत
@ajeh हां। टाइप टाइप (टी) टाइप करने के लिए टाइप करें। गेट टाइप (..)।
जोड़ा लेखक Serj-Tm, स्रोत
सभी आंकड़ों के लिए +1! मुझे इस समय इस तरह के प्रदर्शन की ज़रूरत नहीं है, लेकिन अभी भी बहुत दिलचस्प है। :)
जोड़ा लेखक AnorZaken, स्रोत

यह बहुत आसान है। मान लें कि आपका वर्गनाम कार है और नामस्थान वाहन है, फिर पैरामीटर को Vehers.Car के रूप में पास करें जो प्रकार कार का ऑब्जेक्ट देता है । इस तरह आप गतिशील रूप से किसी भी वर्ग का कोई उदाहरण बना सकते हैं।

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

यदि आपके पूरी तरह से योग्य नाम (यानी , Vehers.Car इस मामले में) किसी अन्य असेंबली में है, 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");
0
जोड़ा
@ डैनमिसर को असेंबली नाम को कड़ी मेहनत करने की आवश्यकता है। लचीलापन लागू करने के लिए मैं शून्य की जांच कर रहा हूं और कोड गतिशील तरीके से काम करता है :)
जोड़ा लेखक Sarath Avanavu, स्रोत
आपके दूसरे मामले (बाहरी असेंबली) में, आप बस अपनी पहली विधि में "वाहन। कर, अन्य एस्सेप्लर" में जा सकते हैं और यह काम करेगा। जाहिर है अन्य एस्सेप्लोर्स उस असेंबली का नाम है जिसमें यह रहता है।
जोड़ा लेखक danmiser, स्रोत

यदि यह किसी ऐसी चीज़ के लिए है जिसे एप्लिकेशन इंस्टेंस में बहुत कुछ कहा जाएगा, तो सक्रियकर्ता या ConstructorInfo.Invoke() का उपयोग करने के बजाय गतिशील कोड को संकलित और कैश करना बहुत तेज़ है। गतिशील संकलन के लिए दो आसान विकल्प संकलित किए गए हैं लिंक अभिव्यक्ति या कुछ सरल IL opcodes और DynamicMethod । किसी भी तरह से, जब आप तंग लूप या एकाधिक कॉल में शामिल होना शुरू करते हैं तो अंतर बहुत बड़ा होता है।

0
जोड़ा
"आईएल opcodes और गतिशील विधि" लिंक मर चुका है।
जोड़ा लेखक Judge Bread, स्रोत
public AbstractType New
{
    get
    {
        return (AbstractType) Activator.CreateInstance(GetType());
    }
}
0
जोड़ा

यदि आप डिफ़ॉल्ट कन्स्ट्रक्टर का उपयोग करना चाहते हैं तो पहले प्रस्तुत किए गए 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 }
    );
0
जोड़ा

इस समस्या को देखते हुए एक्टिवेटर काम करेगा जब पैरामीटर रहित सीटीआर होगा। यदि यह एक बाधा है उपयोग करने पर विचार करें

System.Runtime.Serialization.FormatterServices.GetSafeUninitializedObject()
0
जोड़ा