क्या कोई C # IN ऑपरेटर है?

Question 1

SQL में, आप निम्न सिंटैक्स का उपयोग कर सकते हैं:

SELECT *
FROM MY_TABLE
WHERE VALUE_1 IN (1, 2, 3)

क्या C # में एक समतुल्य है? आईडीई एक कीवर्ड के रूप में "में" को पहचानता है, लेकिन मुझे इस पर कोई जानकारी नहीं मिल रही है।

तो, क्या निम्नलिखित में से कुछ करना संभव है:

int myValue = 1;
if (myValue in (1, 2, 3))
    // Do something

के बजाय

int myValue = 1;
if (myValue == 1 || myValue == 2 || myValue == 3)
    // Do something

Question 2

यदि आप लिखना चाहते हैं। तब आप एक एक्सटेंशन बना सकते हैं जो आपको ऐसा करने की अनुमति देता है।

static class Extensions
{

    public static bool In<T>(this T item, params T[] items)
    {
        if (items == null)
            throw new ArgumentNullException("items");

        return items.Contains(item);
    }

}


class Program
{

    static void Main()
    {


        int myValue = 1;

        if (myValue.In(1, 2, 3))
            // Do Somthing...

        string ds = "Bob";

        if (ds.In("andy", "joel", "matt")) 
        // Do Someting...
    }
}

Question 3

List.Contains()क्या मुझे लगता है कि तुम क्या देख रहे हो। C # में in keywordएक ऐसा नहीं है operatorजो पूरी तरह से अलग उद्देश्य से कार्य करता है और फिर आप SQL में क्या उल्लेख कर रहे हैं।

inC # में कीवर्ड का उपयोग करने के दो तरीके हैं । मान लें कि आपके पास एक स्ट्रिंग है [] या C # में सूची।

        string[] names; //assume there are some names;

        //find all names that start with "a"
        var results = from str in names
                      where str.StartsWith("a")
                      select str;

        //iterate through all names in results and print
        foreach (string name in results)
        {
            Console.WriteLine(name);
        }

आपके संपादन का जिक्र करते हुए, मुझे आपका कोड इस तरह से करना चाहिए कि आपको क्या करना है।

        int myValue = 1;
        List<int> checkValues = new List<int> { 1, 2, 3 };

        if (checkValues.Contains(myValue))
            // Do something

Question 4

तुम यह केर सकते हो:

var x = 99; // searched value

if (new[] {1,2,3,99}.Contains(x))
{
   // do something
}

Question 5

आप आमतौर पर Containsएक संग्रह की विधि का उपयोग करते हैं ।

myCollection.Where(p => Enumerable.Range(1,3).Contains(p));

मुझे उम्मीद है यह मदद करेगा।

Question 6

कोई भी "इन" सी # में ऑपरेटर नहीं है, "इन" कीवर्ड का उपयोग केवल "फॉरचेक (... इन ...)" या "इन ... इन ..." के साथ किया जाता है।

आपकी SQL क्वेरी के बराबर LINQ होगा:

List<int> list = new List<int> { 1, 2, 3 };
var query = from row in my_table
            where list.Contains(row.value1)
            select row;

Question 7

डुप्लिकेट ऑफ़: LINQ to SQL इन और नॉट इन

select * from table where fieldname in ('val1', 'val2')

या

select * from table where fieldname not in (1, 2)

LINQ to SQL में IN और NOT IN प्रश्नों के बराबर कुछ इस तरह होगा:

List<string> validValues = new List<string>() { "val1", "val2"}; 
var qry = from item in dataContext.TableName 
          where validValues.Contains(item.FieldName) 
          select item;

और इस:

List<int> validValues = new List<int>() { 1, 2}; 
var qry = from item in dataContext.TableName 
          where !validValues.Contains(item.FieldName) 
          select item;

Question 8

मैं मानता हूं कि ऑपरेटर को लागू करने का सबसे अच्छा तरीका एक एक्सटेंशन विधि है। मैंने इसे थोड़ा अलग तरीके से किया:

public static bool In(this string str, string CommaDelimintedStringSet)
{
    string[] Values = CommaDelimintedStringSet.Split(new char[] { ',' });
    foreach (string V in Values)
    {
       if (str == V)
         return true;
    }
    return false;
}

अंतर यह है कि आपको प्रत्येक मान के चारों ओर उद्धरण नहीं देना है, केवल कॉमा सीमांकित मानों का पूरा सेट है, जो टाइप करना आसान है:

bool result = MyString.In("Val1,Val2,Val3");

Question 9

आप एक एक्सटेंशन लिख सकते हैं। मैंने एक बार पहले लिखा था, जैसे कोड बनाने के लिए

if(someObject.stringPropertyX.Equals("abc") || someObject.stringPropertyX.Equals("def") || ....){
    //do something
    ...
}else{
   //do something other...
   ....
}

एक एक्स्टेंशन सेंट के साथ अधिक पठनीय लिखने में सक्षम था

if(someObject.stringPropertyX.In("abc", "def",...,"xyz"){
   //do something
   ...
}else{
  //do something other...
  ....
}

यहाँ कोड है :

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Some.Namespace.Extenders
{
    public static class StringExtender
    {
        /// <summary>
        /// Evaluates whether the String is contained in AT LEAST one of the passed values (i.e. similar to the "in" SQL clause)
        /// </summary>
        /// <param name="thisString"></param>
        /// <param name="values">list of strings used for comparison</param>
        /// <returns><c>true</c> if the string is contained in AT LEAST one of the passed values</returns>
        public static bool In(this String thisString, params string[] values)
        {
            foreach (string val in values)
            {
                if (thisString.Equals(val, StringComparison.InvariantCultureIgnoreCase))
                    return true;
            }

            return false; //no occurence found
        }
    }
}

यह उस समय मेरी जरूरतों के लिए विशिष्ट है, लेकिन आप इसे और अधिक विभिन्न प्रकारों के मिलान के लिए अनुकूलित और संशोधित कर सकते हैं।

Question 10

0 से 9 के अंकों के लिए:

"123".Contains(myValue)

किसी भी अन्य सामग्री के लिए:

"|1|2|3|".Contains("|" + myValue + "|")

Question 11

अपने अद्यतन किए गए प्रश्न के लिए, आप स्विच-स्टेटमेंट का भी उपयोग कर सकते हैं।

switch (myvalue)
{
   case 1:
   case 2:
   case 3: 
      // your code goes here
  break;
}

Question 12

ऑपरेटर में ऐसा कोई भी नहीं है जो किसी संग्रह में एक मूल्य की तलाश करता है, इसके बजाय यह संग्रह की एक विधि है, जिसे कहा जाता है Contains।

HashSetसंग्रह के रूप में उपयोग करने के लिए सबसे स्केलेबल समाधान है । एक में मान के लिए जाँच करना HashSetO (1) ऑपरेशन के करीब है, Listजहाँ यह O (n) ऑपरेशन है , वहाँ करने की तुलना में । इसका मतलब है कि आप बहुत सारे मूल्यों को एक में पैक कर सकते हैं HashSetऔर यह अभी भी तेज है, जबकि Listआपके पास जितने अधिक मूल्य हैं, उतने ही धीमी गति से मूल्य की तलाश कर रहे हैं।

उदाहरण:

var set = new HashSet<int>();
set.Add(1);
set.Add(2);
set.Add(3);

var result = items.Select(i => set.Contains(i.value));

Question 13

सामान्य, LINQ तरीका अधिक शक्तिशाली:

var list = new List<string> { "Tomato", "Orange", "Mango"};
var query = from i in my_table
            from v in list
            where i.Name.StartsWith(v)
            select i;

Question 14

inसी # में कीवर्ड के लिए है foreachबयान और LINQ क्वेरी भाव के लिए। inC # प्रति se में SQL के ऑपरेटर के बराबर कोई कार्यक्षमता नहीं है, लेकिन LINQ के साथ समान कार्यक्षमता प्रदान करता है Contains()।

var list = {1, 2, 3}
var filtered = (
    from item in items
    where list.Contains(item)
    select item).ToArray().

Question 15

मैं ऐसा कुछ करता हूं:

var shippingAddress = checkoutContext.Addresses.Where(a => (new HashSet<AddressType> { AddressType.SHIPPING_ONLY, AddressType.BILLING_AND_SHIPPING }).Contains(a.AddressType) && a.Id == long.Parse(orderDto.ShippingAddressId)).FirstOrDefault();