क्या सी # ऑपरेटर है?

Question

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

वहाँ सी # में एक समान है:

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

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

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

के बजाय

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

Answer 1

List.Contains() मुझे लगता है कि आप जो खोज रहे हैं:

तो, यह संभव निम्नलिखित की तरह कुछ करने के लिए है। सी # में inkeyword और operator नहीं है जो कि आप SQL में संदर्भित कर रहे हैं तो पूरी तरह से अलग उद्देश्य प्रदान करता है।

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

 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 

Answer 2

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

अपने 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; 

Answer 3

डुप्लिकेट की: LINQ to SQL in and not in

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

या

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

LINQ में में के बराबर और नहीं प्रश्नों में एसक्यूएल के लिए ऐसा कुछ होगा:

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; 

Answer 4

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

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

मुझे आशा है कि इससे मदद मिलती है।

Answer 5

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

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

Answer 6

आप सवाल स्विच

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

Answer 7

की

मेकअप उपयोग के लिए अपडेट के लिए आप एक विस्तार लिख सकते हैं।मैंने एक बार पहले लिखा था,

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... 
    .... 
} 

लिखने में सक्षम था यहाँ code है:

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 
     } 
    } 
} 

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

Answer 8

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

सबसे स्केलेबल समाधान संग्रह के रूप में HashSet का उपयोग करना है। HashSet में किसी मान के लिए जांच करना List में ऐसा करने की तुलना में ओ (1) ऑपरेशन के करीब है, जहां यह ओ (एन) ऑपरेशन है। इसका मतलब है कि आप 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)); 

Answer 9

आप .इसके लिखने के लिए तो आप एक विस्तार है कि आप ऐसा करने की अनुमति देता है बना सकते हैं चाहता है तो।

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... 
    } 
} 

Answer 10

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

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"); 

Answer 11

आप ऐसा कर सकते हैं:

var x = 99; // searched value 

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

Answer 12

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

"123".Contains(myValue) 

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

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