SQLలో ఎడమ పట్టిక మరియు కుడి పట్టిక నుండి సరిపోలే రికార్డులను ప్రదర్శించడానికి ఎడమ బాహ్య జాయిన్ అనేది ఒక రకమైన చేరిక ఆపరేషన్ ఉపయోగించబడుతుంది. LINQలో, GroupJoin() మరియు SelectMany() పద్ధతులను ఉపయోగించి ఎడమ బాహ్య చేరికను నిర్వహించవచ్చు, ఈ కథనం C#ని ఉపయోగించి LINQలో ఎడమవైపున చేరడం గురించి విస్తృతంగా చర్చిస్తుంది.
C#ని ఉపయోగించి LINQలో లెఫ్ట్ ఔటర్ జాయిన్‌లను ఎలా నిర్వహించాలి
LINQలో ఎడమ బాహ్య చేరికను నిర్వహించడానికి, మీరు ఉమ్మడి కీ ఆధారంగా రెండు సీక్వెన్స్‌లలో చేరడానికి GroupJoin() పద్ధతిని ఉపయోగించవచ్చు మరియు ఫలితాన్ని చదును చేయడానికి SelectMany() పద్ధతిని ఉపయోగించవచ్చు, ఇక్కడ ఒక ఉదాహరణ ఉంది:
వ్యవస్థను ఉపయోగించడం;
System.Linqని ఉపయోగించడం;
తరగతి కార్యక్రమం
{
స్టాటిక్ శూన్య ప్రధాన ( )
{
var left = కొత్త [ ] { 1 , 2 , 3 } ;
var right = కొత్త [ ] { 2 , 3 , 4 } ;
var ఫలితం = ఎడమ.GroupJoin (
కుడి,
l = > l,
r = > r,
( ఎల్, ఆర్ ) = > కొత్త { ఎడమ = l, కుడి = r.DefaultIfEmpty ( ) } )
.ఎంచుకోండి అనేక (
lr = > lr.రైట్.ఎంచుకోండి (
r = > కొత్త { ఎడమ = lr.ఎడమ, కుడి = r } ) ) ;
ప్రతి ( var అంశం లో ఫలితం )
{
కన్సోల్.WriteLine ( '{0} {1}' , అంశం.ఎడమ, అంశం.కుడి ) ;
}
}
}
ఈ కోడ్ ఎడమ మరియు కుడి రెండు శ్రేణులలో ఎడమ బాహ్య చేరికను నిర్వహిస్తుంది మరియు ఫలితాన్ని కన్సోల్‌కు ముద్రిస్తుంది. GroupJoin() పద్ధతి చేరికను నిర్వహిస్తుంది మరియు చాలా ఎంచుకోండి() ఫలితాన్ని చదును చేయడానికి పద్ధతి ఉపయోగించబడుతుంది. చివరగా, ఫలితం foreach లూప్ మరియు WriteLine() ఫంక్షన్ ఉపయోగించి కన్సోల్‌కు ముద్రించబడుతుంది:
సంబంధిత ఉద్యోగి పేర్లు మరియు వారి సంబంధిత విభాగాలను ప్రదర్శించడం ద్వారా వదిలివేయబడిన చేరికలను ప్రదర్శించే వినియోగాన్ని ప్రదర్శించే మరొక ఉదాహరణ ఇక్కడ ఉంది. ప్రతి ఉద్యోగి ఒక్కో డిపార్ట్‌మెంట్‌కి ఒక నంబర్ కేటాయించబడింది, ఆ తర్వాత సంబంధిత డిపార్ట్‌మెంట్‌ని సంబంధిత ఉద్యోగికి సరిపోల్చడానికి ఉపయోగిస్తారు, దానికి సంబంధించిన పూర్తి కోడ్ ఇక్కడ ఉంది:
వ్యవస్థను ఉపయోగించడం;System.Collections.Generic ఉపయోగించి;
System.Linqని ఉపయోగించడం;
నేమ్‌స్పేస్ యువర్ నేమ్‌స్పేస్
{
తరగతి కార్యక్రమం
{
స్టాటిక్ శూన్యమైన ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ )
{
జాబితా < ఉద్యోగి పేరు > ఉద్యోగులు = కొత్త జాబితా < ఉద్యోగి పేరు >
{
కొత్త ఉద్యోగి పేరు { Id = 1 , పేరు = 'తాను' , DepartmentId = 1 } ,
కొత్త ఉద్యోగి పేరు { Id = 2 , పేరు = 'జాన్' , DepartmentId = 2 } ,
కొత్త ఉద్యోగి పేరు { Id = 3 , పేరు = 'కెవిన్' , DepartmentId = 2 } ,
కొత్త ఉద్యోగి పేరు { Id = 4 , పేరు = 'బాబ్' , DepartmentId = 3 }
} ;
జాబితా < శాఖ > విభాగాలు = కొత్త జాబితా < శాఖ >
{
కొత్త శాఖ { Id = 1 , పేరు = 'కంటెంట్ రైటింగ్' } ,
కొత్త శాఖ { Id = 2 , పేరు = 'మార్కెటింగ్' } ,
కొత్త శాఖ { Id = 3 , పేరు = 'ఇంజనీరింగ్' }
} ;
var query = ఉద్యోగి పేరు నుండి లో ఉద్యోగులు
చేరండి శాఖ లో విభాగాలు
ఉద్యోగి పేరుపై.DepartmentId డిపార్ట్‌మెంట్‌కి సమానం.Id డిపార్ట్‌మెంట్‌గ్రూప్‌లోకి
శాఖ నుండి లో DepartmentGroup.DefaultIfEmpty ( )
ఎంచుకోండి కొత్త { EmployeenameName = ఉద్యోగి పేరు.పేరు, DepartmentName = డిపార్ట్‌మెంట్?.పేరు ?? 'ఏదీ లేదు' } ;
ప్రతి ( ఫలితంగా ఉంది లో ప్రశ్న )
{
కన్సోల్.WriteLine ( $ 'ఉద్యోగి పేరు: {result.EmployeenameName}, విభాగం: {result.DepartmentName}' ) ;
}
}
}
తరగతి ఉద్యోగి పేరు
{
పబ్లిక్ int Id { పొందండి; సెట్ ; }
పబ్లిక్ స్ట్రింగ్ పేరు { పొందండి; సెట్ ; }
పబ్లిక్ int DepartmentId { పొందండి; సెట్ ; }
}
తరగతి విభాగం
{
పబ్లిక్ int Id { పొందండి; సెట్ ; }
పబ్లిక్ స్ట్రింగ్ పేరు { పొందండి; సెట్ ; }
}
}
మొదటగా ఒక నమూనా డేటా ఇవ్వబడుతుంది, అందులో ఉద్యోగి పేరు మరియు డిపార్ట్‌మెంట్ల పేరు ఉంటుంది మరియు తర్వాత ఒక్కొక్కరికి సంబంధిత నంబర్ ఇవ్వబడుతుంది. తదుపరి జాయిన్ కమాండ్ ఉపయోగించి జాయిన్ ఆపరేషన్ జరుగుతుంది మరియు ఆ తర్వాత ఫలితం వేరియబుల్ అనే ప్రశ్నలో సేవ్ చేయబడుతుంది, తదుపరి సంబంధిత ఉద్యోగుల పేర్లు మరియు విభాగాలను ప్రింట్ చేయడానికి for loop ఉపయోగించబడుతుంది మరియు కోడ్ అవుట్‌పుట్ ఇలా ఉంటుంది :
ముగింపు
లెఫ్ట్ ఔటర్ జాయిన్ అనేది SQLలో ఒక సాధారణ ఆపరేషన్, మరియు C#లో LINQని ఉపయోగించి కూడా సులభంగా నిర్వహించవచ్చు. GroupJoin() మరియు SelectMany() పద్ధతులను ఉపయోగించి, మీరు ఒక సాధారణ కీ ఆధారంగా రెండు సీక్వెన్స్‌లలో ఎడమ బాహ్య చేరికలను చేయవచ్చు. LINQలో లెఫ్ట్ ఔటర్ జాయిన్‌లను నిర్వహించడానికి సింటాక్స్ ప్రారంభకులకు అర్థం చేసుకోవడం కష్టంగా ఉన్నప్పటికీ, ఇది సంక్లిష్టమైన ప్రశ్నలను సులభంగా అమలు చేయడానికి అనుమతించే శక్తివంతమైన మరియు సౌకర్యవంతమైన భాష.