मैं BooleanToVisibilityConverter का उलटा कैसे कर सकता हूं?


143

मैं BooleanToVisibilityConverterWPF का उपयोग कर रहा हूँ Visibilityएक नियंत्रण की संपत्ति को बांधने के लिए Boolean। यह ठीक काम करता है, लेकिन अगर बूलियन है true, तो मैं इसे छिपाने के लिए नियंत्रणों में से एक चाहूंगा और अगर यह दिखा तो false


ध्यान दें: बीटा 4 के रूप में - Silverlight BooleanToVisibility शामिल नहीं है - तो आप इसे अपने आप को लागू करने के लिए वैसे भी आवश्यकता होगी
Simon_Weaver

समर्थित की विपरीत पाने के लिए एक उपयोगकर्ता आवाज सुझाव जोड़ा visualstudio.uservoice.com/forums/121579-visual-studio-2015/...
Thraka

मुझे विश्वास नहीं हो रहा है कि उन्होंने इस तरह की चीजें करने के लिए कुछ कनवर्टर मापदंडों को लागू नहीं किया।
कामिल

जवाबों:


18

IValueConverter के अपने स्वयं के कार्यान्वयन को लागू करें। एक नमूना कार्यान्वयन पर है

http://msdn.microsoft.com/en-us/library/system.windows.data.ivalueconverter.aspx

अपनी रूपांतरित विधि में, मानों के बजाय वह मान लौटाएं जो आप चाहते हैं।


250

Inverting के बजाय, आप जेनेरिक IValueConverterकार्यान्वयन का उपयोग करके उसी लक्ष्य को प्राप्त कर सकते हैं जो एक बूलियन मान को सही और गलत के लिए कॉन्फ़िगर करने योग्य लक्ष्य मानों में बदल सकता है । नीचे एक ऐसा कार्यान्वयन है:

public class BooleanConverter<T> : IValueConverter
{
    public BooleanConverter(T trueValue, T falseValue)
    {
        True = trueValue;
        False = falseValue;
    }

    public T True { get; set; }
    public T False { get; set; }

    public virtual object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return value is bool && ((bool) value) ? True : False;
    }

    public virtual object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        return value is T && EqualityComparer<T>.Default.Equals((T) value, True);
    }
}

इसके बाद, यह उपवर्ग जहां Tहै Visibility:

public sealed class BooleanToVisibilityConverter : BooleanConverter<Visibility>
{
    public BooleanToVisibilityConverter() : 
        base(Visibility.Visible, Visibility.Collapsed) {}
}

अंत में, यह है कि आप BooleanToVisibilityConverterXAML में ऊपर का उपयोग कैसे कर सकते हैं और इसे कॉन्फ़िगर कर सकते हैं, उदाहरण के लिए, Collapsedसही और Visibleगलत के लिए उपयोग करें :

<Application.Resources>
    <app:BooleanToVisibilityConverter 
        x:Key="BooleanToVisibilityConverter" 
        True="Collapsed" 
        False="Visible" />
</Application.Resources>

यह उलटा उपयोगी है जब आप एक बूलियन संपत्ति का IsHiddenविरोध करने के लिए बाध्य करना चाहते हैं IsVisible


मुझे कुछ याद आ रहा है, लेकिन क्या आपको एक उपेक्षित संपत्ति की आवश्यकता नहीं है? stackoverflow.com/questions/534575/…
OscarRyz

9
@OscarRyz: अधिक जटिल UI के साथ, जो व्यू मॉडल्स में बहुत अधिक कष्टप्रद अव्यवस्था जोड़ने के लिए शुरू होता है, कोड कवरेज बनाए रखने के लिए आपको सैद्धांतिक रूप से एक और संपत्ति का उल्लेख नहीं करना पड़ता है। मॉडल दृश्य प्राप्त करने का नहीं होना चाहिए कि देखने के कार्यान्वयन विवरण के पास, अन्यथा आप के साथ-साथ बस हो सकता है Visibilityआपके विचार मॉडल में गुण।
Aaronaught

यह इतना आसान है, लेकिन काफी मददगार है। साभार @AtifAziz
TheLastGIS

48
using System;
using System.Globalization;
using System.Windows;
using System.Windows.Data;

public sealed class BooleanToVisibilityConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        var flag = false;
        if (value is bool)
        {
            flag = (bool)value;
        }
        else if (value is bool?)
        {
            var nullable = (bool?)value;
            flag = nullable.GetValueOrDefault();
        }
        if (parameter != null)
        {
            if (bool.Parse((string)parameter))
            {
                flag = !flag;
            }
        }
        if (flag)
        {
            return Visibility.Visible;
        }
        else
        {
            return Visibility.Collapsed;
        }
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        var back = ((value is Visibility) && (((Visibility)value) == Visibility.Visible));
        if (parameter != null)
        {
            if ((bool)parameter)
            {
                back = !back;
            }
        }
        return back;
    }
}

और फिर एक सही या गलत के रूप में PassParameter पास करें

       <Grid.Visibility>
                <Binding Path="IsYesNoButtonSetVisible" Converter="{StaticResource booleanToVisibilityConverter}" ConverterParameter="true"/>
        </Grid.Visibility>

4
पर else if (value is bool?)हिस्सा है, ReSharper मुझसे कहता है "अभिव्यक्ति हमेशा गलत है।" इसके अलावा, इस if (flag)भाग को और अधिक संक्षेप में फिर से लिखा जा सकता है return flag ? Visibility.Visible : Visibility.Collapsed;
डेनिलो बार्गेन

1
मुझे कुछ याद आ रहा है, लेकिन क्या आपको एक उपेक्षित संपत्ति की आवश्यकता नहीं है? stackoverflow.com/questions/534575/…
OscarRyz

1
var nullable = (bool?)value; flag = nullable.GetValueOrDefault();बहुत छोटा और सरल बनाया जा सकता है:flag = (bool?)value ?? false;
15

45

अपना खुद का लिखें अब के लिए सबसे अच्छा समाधान है। यहाँ एक कनवर्टर का एक उदाहरण है जो सामान्य और उलटा दोनों तरह से कर सकता है। यदि आपको इससे कोई समस्या है तो बस पूछें।

[ValueConversion(typeof(bool), typeof(Visibility))]
public class InvertableBooleanToVisibilityConverter : IValueConverter
{
    enum Parameters
    {
        Normal, Inverted
    }

    public object Convert(object value, Type targetType,
                          object parameter, CultureInfo culture)
    {
        var boolValue = (bool)value;
        var direction = (Parameters)Enum.Parse(typeof(Parameters), (string)parameter);

        if(direction == Parameters.Inverted)
            return !boolValue? Visibility.Visible : Visibility.Collapsed;

        return boolValue? Visibility.Visible : Visibility.Collapsed;
    }

    public object ConvertBack(object value, Type targetType,
        object parameter, CultureInfo culture)
    {
        return null;
    }
}
<UserControl.Resources>
  <Converters:InvertableBooleanToVisibilityConverter x:Key="_Converter"/>
</UserControl.Resources>

<Button Visibility="{Binding IsRunning, Converter={StaticResource _Converter}, ConverterParameter=Inverted}">Start</Button>

2
बस एक चीज जीतना। Xaml कोड "बाइंडिंग इस्राइन्गिंग", ऑब्जेक्ट "IsRunning" के लिए सॉरकोड या मान कहाँ है?
व्हाट्सअप

IsRunning मेरे दृष्टिकोण पर एक संपत्ति है। इस कोड का संदर्भ लंबा है, लेकिन इसकी कमी यह है कि जब मुझे कुछ गणना और अन्य चीजों को छिपाया जा रहा था, तो मुझे किसी चीज़ को छिपाने की आवश्यकता थी। मैंने इसे बनाने के लिए इस कन्वर्टर को बनाया है ताकि मुझे अपने व्यूमोडल पर एक से अधिक गुण न रखने पड़ें।
माइकल होहलियो

2
BooleanToVisibilityConverterअशक्त के लिए पैरामीटर की जाँच करके आप इसे सामान्य के लिए एक ड्रॉप-इन रिप्लेसमेंट बना सकते हैं :Parameter direction = Parameter.Normal; if (parameter != null) direction = (Parameter)Enum.Parse(typeof(Parameter), (string)parameter);
JCH2k

20

कोडप्लेक्स पर WPF कन्वर्टर्स परियोजना भी है । अपने प्रलेखन में वे कहते हैं कि आप अपने मैपकॉर्टर का उपयोग दृश्यता गणन से बूल में बदलने के लिए कर सकते हैं

<Label>
    <Label.Visible>
        <Binding Path="IsVisible">
            <Binding.Converter>
                <con:MapConverter>
                    <con:Mapping From="True" To="{x:Static Visibility.Visible}"/>
                    <con:Mapping From="False" To="{x:Static Visibility.Hidden}"/>
                </con:MapConverter>
            </Binding.Converter>
        </Binding>
    </Label.Visible>
</Label>

1
WPF कन्वर्टर्स में अब एक BooleanToVisibilityConverter शामिल है जिसे उलटा किया जा सकता है।
विनोद

17

Xaml कंट्रोल विजिबिलिटी प्रॉपर्टी के साथ एक और तरीका है ViewModel बूलियन वैल्यू (IsButtonVanish) को बांधने का। कोई कोडिंग, कोई परिवर्तित, सिर्फ स्टाइल।

<Style TargetType={x:Type Button} x:Key="HideShow">
   <Style.Triggers>
      <DataTrigger Binding="{Binding IsButtonVisible}" Value="False">
          <Setter Property="Visibility" Value="Hidden"/>
      </DataTrigger>
   </Style.Triggers>
</Style>

<Button Style="{StaticResource HideShow}">Hello</Button>

15

या असली आलसी आदमी रास्ता, बस का उपयोग करें जो पहले से ही है और इसे फ्लिप करें:

public class InverseBooleanToVisibilityConverter : IValueConverter
{
    private BooleanToVisibilityConverter _converter = new BooleanToVisibilityConverter();

    public object Convert(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        var result = _converter.Convert(value, targetType, parameter, culture) as Visibility?;
        return result == Visibility.Collapsed ? Visibility.Visible : Visibility.Collapsed;
    }

    public object ConvertBack(object value, Type targetType, object parameter, System.Globalization.CultureInfo culture)
    {
        var result = _converter.ConvertBack(value, targetType, parameter, culture) as bool?;
        return result == true ? false : true;
    }
}

5

यदि आपको कस्टम कनवर्टर लिखना पसंद नहीं है, तो आप इसे हल करने के लिए डेटा ट्रिगर का उपयोग कर सकते हैं:

<Style.Triggers>
        <DataTrigger Binding="{Binding YourBinaryOption}" Value="True">
                 <Setter Property="Visibility" Value="Visible" />
        </DataTrigger>
        <DataTrigger Binding="{Binding YourBinaryOption}" Value="False">
                 <Setter Property="Visibility" Value="Collapsed" />
        </DataTrigger>
</Style.Triggers>

3

मैंने अभी इस पर एक पोस्ट किया है। मैंने माइकल हॉलीलोस के समान विचार का उपयोग किया था। केवल, मैंने "ऑब्जेक्ट पैरामीटर" का उपयोग करने के बजाय गुण का उपयोग किया।

WPF

गुणों का उपयोग कर एक बूल मान के लिए बाइंडिंग दृश्यता यह मेरी राय में, अधिक पठनीय बनाता है।

<local:BoolToVisibleOrHidden x:Key="BoolToVisConverter" Collapse="True" Reverse="True" />

मेरी अपनी टिप्पणी पर बस एक अनुवर्ती। यदि आप गुण का उपयोग करते हैं, तो आपको एक अलग ऑब्जेक्ट बनाना होगा यदि आप कन्वर्टर्स को बनाना चाहते हैं, तो एक जो रिवर्स है और एक नहीं है। यदि आप मापदंडों का उपयोग करते हैं, तो आप कई वस्तुओं के लिए एक ऑब्जेक्ट का उपयोग कर सकते हैं, लेकिन यदि आप ध्यान नहीं देते हैं तो यह भ्रमित हो सकता है। इसलिए दोनों के पक्ष और विपक्ष हैं।
रयूस जूल 25'11

मैंने बूलियन को कलर्स कन्वर्टर्स को साकार करने में बहुत मददगार पाया। धन्यवाद
Federinik

3

यहाँ एक मैंने लिखा है और बहुत उपयोग किया है। यह एक बूलियन कन्वर्टर पैरामीटर का उपयोग करता है जो इंगित करता है कि मान को उलटा करना है या नहीं और फिर नकारने के लिए XOR का उपयोग करता है:

[ValueConversion(typeof(bool), typeof(System.Windows.Visibility))]
public class BooleanVisibilityConverter : IValueConverter
{
    System.Windows.Visibility _visibilityWhenFalse = System.Windows.Visibility.Collapsed;

    /// <summary>
    /// Gets or sets the <see cref="System.Windows.Visibility"/> value to use when the value is false. Defaults to collapsed.
    /// </summary>
    public System.Windows.Visibility VisibilityWhenFalse
    {
        get { return _visibilityWhenFalse; }
        set { _visibilityWhenFalse = value; }
    }

    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
    {
        bool negateValue;
        Boolean.TryParse(parameter as string, out negateValue);

        bool val = negateValue ^ System.Convert.ToBoolean(value); //Negate the value when negateValue is true using XOR
        return val ? System.Windows.Visibility.Visible : _visibilityWhenFalse;
    }

    public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
    {
        bool negateValue;
        Boolean.TryParse(parameter as string, out negateValue);

        if ((System.Windows.Visibility)value == System.Windows.Visibility.Visible)
            return true ^ negateValue;
        else
            return false ^ negateValue;
    }
}

यहाँ संदर्भ के लिए एक XOR सत्य तालिका है:

        XOR
        x  y  XOR
        ---------
        0  0  0
        0  1  1
        1  0  1
        1  1  0

2

मैं एक अधिक सामान्य उत्तर की तलाश में था, लेकिन यह नहीं मिल सका। मैंने एक कनवर्टर लिखा है जो दूसरों की मदद कर सकता है।

यह इस तथ्य पर आधारित है कि हमें छह अलग-अलग मामलों को अलग करने की आवश्यकता है:

  • सच 2 दर्शनीय, झूठी 2 छिपी
  • सच 2 दर्शनीय, झूठी 2 ढह गई
  • सच 2 छिपे, झूठे 2 दर्शनीय
  • ट्रू 2 कोलैप्स, फाल्स 2 विजिबल
  • सच 2 छिपे, झूठे 2 टूटे हुए
  • ट्रू 2 कोलैप्स, फाल्स 2 हिडन

यहाँ पहले 4 मामलों के लिए मेरा कार्यान्वयन है:

[ValueConversion(typeof(bool), typeof(Visibility))]
public class BooleanToVisibilityConverter : IValueConverter
{
    enum Types
    {
        /// <summary>
        /// True to Visible, False to Collapsed
        /// </summary>
        t2v_f2c,
        /// <summary>
        /// True to Visible, False to Hidden
        /// </summary>
        t2v_f2h,
        /// <summary>
        /// True to Collapsed, False to Visible
        /// </summary>
        t2c_f2v,
        /// <summary>
        /// True to Hidden, False to Visible
        /// </summary>
        t2h_f2v,
    }
    public object Convert(object value, Type targetType,
                          object parameter, CultureInfo culture)
    {
        var b = (bool)value;
        string p = (string)parameter;
        var type = (Types)Enum.Parse(typeof(Types), (string)parameter);
        switch (type)
        {
            case Types.t2v_f2c:
                return b ? Visibility.Visible : Visibility.Collapsed; 
            case Types.t2v_f2h:
                return b ? Visibility.Visible : Visibility.Hidden; 
            case Types.t2c_f2v:
                return b ? Visibility.Collapsed : Visibility.Visible; 
            case Types.t2h_f2v:
                return b ? Visibility.Hidden : Visibility.Visible; 
        }
        throw new NotImplementedException();
    }

    public object ConvertBack(object value, Type targetType,
        object parameter, CultureInfo culture)
    {
        var v = (Visibility)value;
        string p = (string)parameter;
        var type = (Types)Enum.Parse(typeof(Types), (string)parameter);
        switch (type)
        {
            case Types.t2v_f2c:
                if (v == Visibility.Visible)
                    return true;
                else if (v == Visibility.Collapsed)
                    return false;
                break;
            case Types.t2v_f2h:
                if (v == Visibility.Visible)
                    return true;
                else if (v == Visibility.Hidden)
                    return false;
                break;
            case Types.t2c_f2v:
                if (v == Visibility.Visible)
                    return false;
                else if (v == Visibility.Collapsed)
                    return true;
                break;
            case Types.t2h_f2v:
                if (v == Visibility.Visible)
                    return false;
                else if (v == Visibility.Hidden)
                    return true;
                break;
        }
        throw new InvalidOperationException();
    }
}

उदाहरण:

Visibility="{Binding HasItems, Converter={StaticResource BooleanToVisibilityConverter}, ConverterParameter='t2v_f2c'}"

मुझे लगता है कि मापदंडों को याद रखना आसान है।

आशा है कि यह किसी की मदद करता है।


2

आप QuickConverter का उपयोग कर सकते हैं ।

QuickConverter के साथ आप अपने BindingExpression के साथ कनवर्टर तर्क इनलाइन लिख सकते हैं

यहाँ एक उलटा बूलियनट्विसिबिलिटी कनवर्टर है:

Visibility="{qc:Binding '!$P ? Visibility.Visible : Visibility.Collapsed', P={Binding Example}}"

आप NuGet के माध्यम से QuickConverter जोड़ सकते हैं। सेटअप के लिए दस्तावेज़ीकरण पर एक नज़र डालें। लिंक: https://quickconverter.codeplex.com/


1

अपनी खुद की कन्वर्ट लिखें।

public class ReverseBooleanToVisibilityConverter : IValueConverter
{
    public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
   {
       // your converter code here
   }
}

0

एक सरल एक तरीका संस्करण जो इस तरह इस्तेमाल किया जा सकता है:

Visibility="{Binding IsHidden, Converter={x:Static Ui:Converters.BooleanToVisibility}, ConverterParameter=true}

इस तरह लागू किया जा सकता है:

public class BooleanToVisibilityConverter : IValueConverter
{
  public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
  {
    var invert = false;

    if (parameter != null)
    {
      invert = Boolean.Parse(parameter.ToString());
    }

    var booleanValue = (bool) value;

    return ((booleanValue && !invert) || (!booleanValue && invert)) 
      ? Visibility.Visible : Visibility.Collapsed;
  }

  public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
  {
    throw new NotImplementedException();
  }
}

0

सब कुछ (बूल, स्ट्रिंग, एनम, आदि) में परिवर्तित करें:

public class EverythingConverterValue
{
    public object ConditionValue { get; set; }
    public object ResultValue { get; set; }
}

public class EverythingConverterList : List<EverythingConverterValue>
{

}

public class EverythingConverter : IValueConverter
{
    public EverythingConverterList Conditions { get; set; } = new EverythingConverterList();

    public object NullResultValue { get; set; }
    public object NullBackValue { get; set; }

    public object Convert(object value, Type targetType,
        object parameter, CultureInfo culture)
    {
        return Conditions.Where(x => x.ConditionValue.Equals(value)).Select(x => x.ResultValue).FirstOrDefault() ?? NullResultValue;
    }
    public object ConvertBack(object value, Type targetType,
        object parameter, CultureInfo culture)
    {
        return Conditions.Where(x => x.ResultValue.Equals(value)).Select(x => x.ConditionValue).FirstOrDefault() ?? NullBackValue;
    }
}

XAML उदाहरण:

<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                xmlns:conv="clr-namespace:MvvmGo.Converters;assembly=MvvmGo.WindowsWPF"
                xmlns:sys="clr-namespace:System;assembly=mscorlib">

<conv:EverythingConverter x:Key="BooleanToVisibilityConverter">
    <conv:EverythingConverter.Conditions>
        <conv:EverythingConverterValue ResultValue="{x:Static Visibility.Visible}">
            <conv:EverythingConverterValue.ConditionValue>
                <sys:Boolean>True</sys:Boolean>
            </conv:EverythingConverterValue.ConditionValue>
        </conv:EverythingConverterValue>
        <conv:EverythingConverterValue ResultValue="{x:Static Visibility.Collapsed}">
            <conv:EverythingConverterValue.ConditionValue>
                <sys:Boolean>False</sys:Boolean>
            </conv:EverythingConverterValue.ConditionValue>
        </conv:EverythingConverterValue>
    </conv:EverythingConverter.Conditions>

</conv:EverythingConverter>

<conv:EverythingConverter x:Key="InvertBooleanToVisibilityConverter">
    <conv:EverythingConverter.Conditions>
        <conv:EverythingConverterValue ResultValue="{x:Static Visibility.Visible}">
            <conv:EverythingConverterValue.ConditionValue>
                <sys:Boolean>False</sys:Boolean>
            </conv:EverythingConverterValue.ConditionValue>
        </conv:EverythingConverterValue>
        <conv:EverythingConverterValue ResultValue="{x:Static Visibility.Collapsed}">
            <conv:EverythingConverterValue.ConditionValue>
                <sys:Boolean>True</sys:Boolean>
            </conv:EverythingConverterValue.ConditionValue>
        </conv:EverythingConverterValue>
    </conv:EverythingConverter.Conditions>
</conv:EverythingConverter>

<conv:EverythingConverter x:Key="MarriedConverter" NullResultValue="Single">
    <conv:EverythingConverter.Conditions>
        <conv:EverythingConverterValue ResultValue="Married">
            <conv:EverythingConverterValue.ConditionValue>
                <sys:Boolean>True</sys:Boolean>
            </conv:EverythingConverterValue.ConditionValue>
        </conv:EverythingConverterValue>
        <conv:EverythingConverterValue ResultValue="Single">
            <conv:EverythingConverterValue.ConditionValue>
                <sys:Boolean>False</sys:Boolean>
            </conv:EverythingConverterValue.ConditionValue>
        </conv:EverythingConverterValue>
    </conv:EverythingConverter.Conditions>
    <conv:EverythingConverter.NullBackValue>
        <sys:Boolean>False</sys:Boolean>
    </conv:EverythingConverter.NullBackValue>
</conv:EverythingConverter>


0

अपना स्वयं का कोड लिखने / पुनर्निवेश करने के बजाय, CalcBinding का उपयोग करने पर विचार करें :

Automatic two way convertion of bool expression to Visibility and back if target property has such type: description

    <Button Visibility="{c:Binding !IsChecked}" /> 
    <Button Visibility="{c:Binding IsChecked, FalseToVisibility=Hidden}" />

CalcBinding कई अन्य परिदृश्यों के लिए भी काफी उपयोगी है।


-2

मुझे पता है कि यह दिनांकित है, लेकिन, आपको कुछ भी फिर से लागू करने की आवश्यकता नहीं है।

मैंने इस तरह संपत्ति पर मूल्य को नकारने के लिए क्या किया था:

<!-- XAML code -->
<StackPanel Name="x"  Visibility="{Binding    Path=Specials, ElementName=MyWindow, Converter={StaticResource BooleanToVisibilityConverter}}"></StackPanel>    
<StackPanel Name="y"  Visibility="{Binding Path=NotSpecials, ElementName=MyWindow, Converter={StaticResource BooleanToVisibilityConverter}}"></StackPanel>        

....

//Code behind
public bool Specials
{
    get { return (bool) GetValue(SpecialsProperty); }
    set
    {
        NotSpecials= !value; 
        SetValue(SpecialsProperty, value);
    }
}

public bool NotSpecials
{
    get { return (bool) GetValue(NotSpecialsProperty); }
    set { SetValue(NotSpecialsProperty, value); }
}

और यह ठीक काम करता है!

क्या मैं कुछ भूल रहा हूँ?


7
आपको लगता है कि यह एक आसान समाधान है, और एक ही संपत्ति के लिए यह मामला भी हो सकता है (यह कई गुणों के लिए पुन: प्रयोज्य नहीं है, आपको इसे हर एक के लिए लागू करना होगा)। मुझे लगता है कि यह कार्यान्वयन के लिए गलत जगह है, हालांकि इसका दृश्यमोडल / कोडबाइंड और दृश्य के साथ सब कुछ करने के लिए कुछ भी नहीं है।
माइक फुच्स
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.