Autofixture: अनुकूलन के आधार पर यादृच्छिक नमूना उत्पन्न करने का दृष्टिकोण

यह स्टैक ओवरफ़्लो प्रश्न के लिए एक अच्छे उम्मीदवार की तरह लगता है। यहां एक प्रश्न पूछने में कुछ भी गलत नहीं है, लेकिन मुझे लगता है कि यह प्रश्न उस प्रकार का है जहां एक उत्तर अन्य लोगों को भी लाभ पहुंचा सकता है, और गिटहब मुद्दों की तुलना में स्टैक ओवरफ़्लो पर प्रश्न और उत्तर ढूंढना आसान है। एक के लिए, Google स्टैक ओवरफ़्लो प्रश्नों को अनुक्रमित करने का अच्छा काम करता है, जबकि ऐसा लगता है कि यह रैंक (बंद) गिटहब मुद्दों को कम करता है ...

@ploeh मैं
मैंने अभी इस मुद्दे के आधार पर एक SO प्रश्न बनाया है। यह भविष्य के संदर्भों के लिए

@ploeh SO पर प्रश्न का उत्तर देने के लिए धन्यवाद: ब्लश:

@thiagomajesk वास्तव में यहां सवालों के जवाब देने में कोई समस्या नहीं है। जिस कारण से मार्क ने SO का सुझाव दिया, वह वह खोज क्षमता है जो वह प्रदान करता है। इसके अलावा वर्तमान में मार्क एसओ की निगरानी कर रहा है, इसलिए यदि आप वहां कोई प्रश्न पोस्ट करते हैं, तो उसकी विशेषज्ञता प्राप्त करने की अधिक संभावना है (जैसे आपको इस बार मिला): पसीना_स्माइल:

@zvirja यह स्पष्ट करने के लिए धन्यवाद कि

@zvirja मैं SO पर @ploeh के शानदार उत्तर के आधार पर प्रश्न को बंद करने जा रहा हूं।
लेकिन मैं इस पर कार्यान्वयन विवरण के बारे में कुछ और जानकारी मांगना चाहता हूं।
जैसा कि मैं इस विषय से और भी आगे नहीं बढ़ना चाहता, मुझे लगता है कि इस विवरण के बारे में यहां पूछना बेहतर होगा। तो मेरे पास यह कार्यान्वयन है:

```सी#
पब्लिक क्लास UniqueShortGuidBuilder: आईस्पेसिमेनबिल्डर
{
निजी रीडोनली स्ट्रिंग प्रोपनाम;
निजी रीडोनली इंट लेंथ;

public UniqueShortGuidBuilder(Expression<Func<TEntity, string>> expr, int lenght)
{
    propName = ((MemberExpression)expr.Body).Member.Name;
    this.lenght = lenght;
}

सार्वजनिक वस्तु बनाएँ (वस्तु अनुरोध, ISpecimenContext संदर्भ)
{
var pi = PropertyInfo के रूप में अनुरोध करें;

if (pi == null || pi.PropertyType != typeof(string) || pi.Name != propName)
    return new NoSpecimen();

return Guid.NewGuid().ToString().Substring(0, lenght);

}
```

मैं उम्मीद कर रहा था कि AutoFixture के साथ कई ऑब्जेक्ट बनाते समय, ISpecimenBuilder.Create को कई बार कॉल किया जाएगा, जिससे मेरी संस्थाओं के लिए अलग-अलग गाइड बनेंगे; लेकिन जाहिर तौर पर यह सच नहीं है और वे वास्तव में वही साझा कर रहे हैं।

ठीक है, मैंने अभी आपके कोड का परीक्षण किया है और यह बिल्कुल वांछित काम करता है:

```सी#
सार्वजनिक वर्ग फू
{
सार्वजनिक स्ट्रिंग संपत्ति को अनुकूलित करें {प्राप्त करें; सेट; }
}

पब्लिक क्लास UniqueShortGuidBuilder: आईस्पेसिमेनबिल्डर
{
निजी रीडोनली स्ट्रिंग प्रोपनाम;
निजी रीडोनली इंट लेंथ;

public UniqueShortGuidBuilder(Expression<Func<TEntity, string>> expr, int lenght)
{
    propName = ((MemberExpression) expr.Body).Member.Name;
    this.lenght = lenght;
}

public object Create(object request, ISpecimenContext context)
{
    var pi = request as PropertyInfo;

    if (pi == null || pi.PropertyType != typeof(string) || pi.Name != propName)
        return new NoSpecimen();

    return Guid.NewGuid().ToString().Substring(0, lenght);
}

}

[तथ्य]
सार्वजनिक शून्य परीक्षण अनुकूलन ()
{
वर स्थिरता = नई स्थिरता ();
स्थिरता। अनुकूलन। जोड़ें (नया UniqueShortGuidBuilder .)(x => x.PropertyToCustomize, 5));

var manyFoos = fixture.CreateMany<Foo>(10);

var uniqueIds = manyFoos
    .Select(x => x.PropertyToCustomize)
    .Where(x => x.Length == 5)
    .Distinct()
    .ToArray();
Assert.Equal(10, uniqueIds.Length);

}
```

इसलिए, मैं आपसे फिर से पूछना चाहता हूं कि आपका वास्तविक कोड कैसे भिन्न है, इसलिए हम समझ सकते हैं कि यह अंतर क्यों मायने रखता है

@zvirja यह अजीब है। मेरी समस्या का एक न्यूनतम रेपो कोड है।
अगर मैं Fixture.Customize(new FooCustomization()); को हटा

```सी#
सिस्टम का उपयोग करना;
Microsoft.VisualStudio.TestTools.UnitTesting का उपयोग करना;
AutoFixture.Kernel का उपयोग करना;
System.Linq.Expressions का उपयोग करना;
सिस्टम का उपयोग करना। प्रतिबिंब;
ऑटोफिक्चर का उपयोग करना;
System.Linq का उपयोग करना;

नेमस्पेस यूनिटटेस्टप्रोजेक्ट1
{
सार्वजनिक वर्ग फू
{
सार्वजनिक स्ट्रिंग संपत्ति को अनुकूलित करें {प्राप्त करें; सेट; }
}

public class FooCustomization : ICustomization
{
    public void Customize(IFixture fixture)
    {
        var specimen = fixture.Build<Foo>()
            .OmitAutoProperties()
            .With(x => x.PropertyToCustomize)
            .Create();

        fixture.Register(() => specimen);
    }
}

public class UniqueShortGuidBuilder<TEntity> : ISpecimenBuilder
{
    private readonly string propName;
    private readonly int lenght;

    public UniqueShortGuidBuilder(Expression<Func<TEntity, string>> expr, int lenght)
    {
        propName = ((MemberExpression)expr.Body).Member.Name;
        this.lenght = lenght;
    }

    public object Create(object request, ISpecimenContext context)
    {
        var pi = request as PropertyInfo;

        if (pi == null || pi.PropertyType != typeof(string) || pi.Name != propName)
            return new NoSpecimen();

        return Guid.NewGuid().ToString().Substring(0, lenght);
    }
}

[TestClass]
public class UnitTest1
{
    public static Fixture Fixture { get; private set; }

    [ClassInitialize]
    public static void ClassInitialize(TestContext context)
    {
        Fixture = new Fixture();
        Fixture.Customizations.Add(new UniqueShortGuidBuilder<Foo>(x => x.PropertyToCustomize, 5));
        Fixture.Customize(new FooCustomization());
    }

    [TestMethod]
    public void TestMethod1()
    {
        var manyFoos = Fixture.CreateMany<Foo>(10);

        var uniqueIds = manyFoos
            .Select(x => x.PropertyToCustomize)
            .Where(x => x.Length == 5)
            .Distinct()
            .ToArray();

        Assert.AreEqual(10, uniqueIds.Length);
    }
}

}
```

अनुशंसा: यदि आप GUID स्ट्रिंग से पहले _n_ वर्ण निकालने पर भरोसा करते हैं, तो वर्ग का नाम न दें UniqueShortGuidBuilder । लंबाई 5 होने पर मान काफी विशिष्ट हो सकते हैं, लेकिन यदि आप इसे 1 पर सेट करते हैं, तो आपको टकराव की संभावना दिखाई देगी। किसी भी मामले में, विशिष्टता की गारंटी नहीं है।

यदि आप केवल स्ट्रिंग की लंबाई, साथ ही गैर-गारंटीकृत विशिष्टता के बारे में परवाह करते हैं, तो क्यों न केवल AutoFixture से 0 और 99,999 के बीच की संख्या के लिए पूछें, और इसे एक स्ट्रिंग में बदल दें? IIRC, संख्याएँ तब तक अद्वितीय होती हैं जब तक कि सीमा समाप्त नहीं हो जाती।

अगर मैं फिक्स्चर हटा देता हूं। अनुकूलित करें (नया FooCustomization ()); परीक्षा पास होगी, अन्यथा नहीं।

ठीक है, वास्तव में यह अपेक्षित व्यवहार है यदि आप स्थिति की अधिक सावधानी से समीक्षा करते हैं कृपया मेरा उत्तर #962 में देखें। FooCustomization का प्रदान किया गया कार्यान्वयन Foo प्रकार का उदाहरण बनाता है और उस उदाहरण को हमेशा वापस करने के लिए स्थिरता को कॉन्फ़िगर करता है। इसलिए, जब आप बाद में Foo प्रकार के कई उदाहरण बनाते हैं, तो हर बार एक ही वस्तु वापस आती है और आपके निर्माता को आगे नहीं बुलाया जाता है।

यदि आप चाहते हैं कि हर बार Foo अनुरोध करने पर एक नया उदाहरण बनाया जाए, तो Customize<> API का उपयोग करें जैसा कि मैंने यहां सुझाया

@ploeh टिप के लिए धन्यवाद, लेकिन वह कोड परीक्षण उद्देश्यों के लिए सिर्फ एक सकल उदाहरण है। वास्तविक मामलों के लिए गाइड की विशिष्टता को प्रभावित करने के लिए लंबाई हास्यास्पद रूप से कम नहीं होगी ।

यदि आप केवल स्ट्रिंग की लंबाई, साथ ही गैर-गारंटीकृत विशिष्टता के बारे में परवाह करते हैं, तो क्यों न केवल AutoFixture से 0 और 99,999 के बीच की संख्या के लिए पूछें, और इसे एक स्ट्रिंग में बदल दें?

मैं शर्त लगाता हूं कि यह ज्यादातर मामलों के लिए एक अच्छा समाधान है, लेकिन मैं अपने सिस्टम में अल्फान्यूमेरिक सत्यापन के कारण इस विशिष्ट मामले के लिए ऐसा नहीं कर सकता। इसके अलावा, मेरे पास उस क्षेत्र से जुड़े अधिक जटिल सत्यापन हैं।

ठीक है, वास्तव में यह अपेक्षित व्यवहार है यदि आप स्थिति की अधिक सावधानी से समीक्षा करते हैं

@zvirja # 962 में आपके उत्तर के बाद यह स्पष्ट है। लेकिन मेरे लिए वह व्यवहार स्पष्ट नहीं था, क्योंकि ऑटोफिक्चर के बारे में अग्रिम (स्पष्ट) दस्तावेज नहीं है (जैसे मैंने यहां बताया) ।

समाप्त करने के लिए, धैर्य और सभी उत्कृष्ट स्पष्टीकरणों के लिए आप दोनों का धन्यवाद।
मुझे यकीन है कि यह भविष्य में भी दूसरों के लिए उपयोगी होगा ।

ठीक है, काफी हद तक, मेरे पास चीजों को बहुत अधिक शाब्दिक लेने की प्रवृत्ति हो सकती है 😄